
iphlpapi.nostrip.dll:     file format pei-i386

Disassembly of section .text:

77301000 <_DllMainCRTStartup@12>:
77301000:	55                   	push   %ebp
77301001:	89 e5                	mov    %esp,%ebp
77301003:	57                   	push   %edi
77301004:	56                   	push   %esi
77301005:	53                   	push   %ebx
77301006:	83 ec 0c             	sub    $0xc,%esp
77301009:	8b 7d 0c             	mov    0xc(%ebp),%edi
7730100c:	83 ff 01             	cmp    $0x1,%edi
7730100f:	0f 84 ab 00 00 00    	je     773010c0 <_DllMainCRTStartup@12+0xc0>
77301015:	89 7c 24 04          	mov    %edi,0x4(%esp)
77301019:	8b 5d 10             	mov    0x10(%ebp),%ebx
7730101c:	8b 4d 08             	mov    0x8(%ebp),%ecx
7730101f:	89 5c 24 08          	mov    %ebx,0x8(%esp)
77301023:	89 0c 24             	mov    %ecx,(%esp)
77301026:	e8 35 1d 00 00       	call   77302d60 <_DllMain@12>
7730102b:	89 c6                	mov    %eax,%esi
7730102d:	83 ec 0c             	sub    $0xc,%esp
77301030:	83 ff 01             	cmp    $0x1,%edi
77301033:	0f 94 c2             	sete   %dl
77301036:	31 c0                	xor    %eax,%eax
77301038:	85 f6                	test   %esi,%esi
7730103a:	0f 94 c0             	sete   %al
7730103d:	85 c2                	test   %eax,%edx
7730103f:	74 5b                	je     7730109c <_DllMainCRTStartup@12+0x9c>
77301041:	8b 15 00 c0 30 77    	mov    0x7730c000,%edx
77301047:	85 d2                	test   %edx,%edx
77301049:	74 45                	je     77301090 <_DllMainCRTStartup@12+0x90>
7730104b:	8b 1d 10 c0 30 77    	mov    0x7730c010,%ebx
77301051:	eb 0d                	jmp    77301060 <_DllMainCRTStartup@12+0x60>
77301053:	90                   	nop    
77301054:	90                   	nop    
77301055:	90                   	nop    
77301056:	90                   	nop    
77301057:	90                   	nop    
77301058:	90                   	nop    
77301059:	90                   	nop    
7730105a:	90                   	nop    
7730105b:	90                   	nop    
7730105c:	90                   	nop    
7730105d:	90                   	nop    
7730105e:	90                   	nop    
7730105f:	90                   	nop    
77301060:	83 eb 04             	sub    $0x4,%ebx
77301063:	39 d3                	cmp    %edx,%ebx
77301065:	72 19                	jb     77301080 <_DllMainCRTStartup@12+0x80>
77301067:	8b 03                	mov    (%ebx),%eax
77301069:	85 c0                	test   %eax,%eax
7730106b:	74 f3                	je     77301060 <_DllMainCRTStartup@12+0x60>
7730106d:	ff d0                	call   *%eax
7730106f:	8b 15 00 c0 30 77    	mov    0x7730c000,%edx
77301075:	83 eb 04             	sub    $0x4,%ebx
77301078:	39 d3                	cmp    %edx,%ebx
7730107a:	73 eb                	jae    77301067 <_DllMainCRTStartup@12+0x67>
7730107c:	8d 74 26 00          	lea    0x0(%esi),%esi
77301080:	89 14 24             	mov    %edx,(%esp)
77301083:	e8 98 6e 00 00       	call   77307f20 <_free>
77301088:	31 d2                	xor    %edx,%edx
7730108a:	89 15 00 c0 30 77    	mov    %edx,0x7730c000
77301090:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
77301097:	e8 74 6e 00 00       	call   77307f10 <_fflush>
7730109c:	85 ff                	test   %edi,%edi
7730109e:	75 10                	jne    773010b0 <_DllMainCRTStartup@12+0xb0>
773010a0:	8b 15 00 c0 30 77    	mov    0x7730c000,%edx
773010a6:	85 d2                	test   %edx,%edx
773010a8:	75 46                	jne    773010f0 <_DllMainCRTStartup@12+0xf0>
773010aa:	31 f6                	xor    %esi,%esi
773010ac:	8d 74 26 00          	lea    0x0(%esi),%esi
773010b0:	89 f0                	mov    %esi,%eax
773010b2:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773010b5:	5b                   	pop    %ebx
773010b6:	5e                   	pop    %esi
773010b7:	5f                   	pop    %edi
773010b8:	5d                   	pop    %ebp
773010b9:	c2 0c 00             	ret    $0xc
773010bc:	8d 74 26 00          	lea    0x0(%esi),%esi
773010c0:	c7 04 24 80 00 00 00 	movl   $0x80,(%esp)
773010c7:	e8 74 6e 00 00       	call   77307f40 <_malloc>
773010cc:	a3 00 c0 30 77       	mov    %eax,0x7730c000
773010d1:	85 c0                	test   %eax,%eax
773010d3:	74 6c                	je     77301141 <_DllMainCRTStartup@12+0x141>
773010d5:	c7 00 00 00 00 00    	movl   $0x0,(%eax)
773010db:	a3 10 c0 30 77       	mov    %eax,0x7730c010
773010e0:	e8 ab 6a 00 00       	call   77307b90 <__pei386_runtime_relocator>
773010e5:	e8 36 6a 00 00       	call   77307b20 <___main>
773010ea:	e9 26 ff ff ff       	jmp    77301015 <_DllMainCRTStartup@12+0x15>
773010ef:	90                   	nop    
773010f0:	8b 1d 10 c0 30 77    	mov    0x7730c010,%ebx
773010f6:	8d 76 00             	lea    0x0(%esi),%esi
773010f9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi
77301100:	83 eb 04             	sub    $0x4,%ebx
77301103:	39 d3                	cmp    %edx,%ebx
77301105:	72 19                	jb     77301120 <_DllMainCRTStartup@12+0x120>
77301107:	8b 03                	mov    (%ebx),%eax
77301109:	85 c0                	test   %eax,%eax
7730110b:	74 f3                	je     77301100 <_DllMainCRTStartup@12+0x100>
7730110d:	ff d0                	call   *%eax
7730110f:	8b 15 00 c0 30 77    	mov    0x7730c000,%edx
77301115:	83 eb 04             	sub    $0x4,%ebx
77301118:	39 d3                	cmp    %edx,%ebx
7730111a:	73 eb                	jae    77301107 <_DllMainCRTStartup@12+0x107>
7730111c:	8d 74 26 00          	lea    0x0(%esi),%esi
77301120:	89 14 24             	mov    %edx,(%esp)
77301123:	31 ff                	xor    %edi,%edi
77301125:	e8 f6 6d 00 00       	call   77307f20 <_free>
7730112a:	89 3d 00 c0 30 77    	mov    %edi,0x7730c000
77301130:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
77301137:	e8 d4 6d 00 00       	call   77307f10 <_fflush>
7730113c:	e9 6f ff ff ff       	jmp    773010b0 <_DllMainCRTStartup@12+0xb0>
77301141:	e8 ea 6d 00 00       	call   77307f30 <__errno>
77301146:	c7 00 0c 00 00 00    	movl   $0xc,(%eax)
7730114c:	31 c0                	xor    %eax,%eax
7730114e:	e9 5f ff ff ff       	jmp    773010b2 <_DllMainCRTStartup@12+0xb2>
77301153:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77301159:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77301160 <_atexit>:
77301160:	55                   	push   %ebp
77301161:	ba 10 c0 30 77       	mov    $0x7730c010,%edx
77301166:	89 e5                	mov    %esp,%ebp
77301168:	83 ec 18             	sub    $0x18,%esp
7730116b:	b9 00 c0 30 77       	mov    $0x7730c000,%ecx
77301170:	8b 45 08             	mov    0x8(%ebp),%eax
77301173:	89 54 24 08          	mov    %edx,0x8(%esp)
77301177:	89 4c 24 04          	mov    %ecx,0x4(%esp)
7730117b:	89 04 24             	mov    %eax,(%esp)
7730117e:	e8 7d 6d 00 00       	call   77307f00 <___dllonexit>
77301183:	c9                   	leave  
77301184:	83 f8 01             	cmp    $0x1,%eax
77301187:	19 c0                	sbb    %eax,%eax
77301189:	c3                   	ret    
7730118a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

77301190 <__onexit>:
77301190:	55                   	push   %ebp
77301191:	b9 10 c0 30 77       	mov    $0x7730c010,%ecx
77301196:	89 e5                	mov    %esp,%ebp
77301198:	83 ec 18             	sub    $0x18,%esp
7730119b:	ba 00 c0 30 77       	mov    $0x7730c000,%edx
773011a0:	8b 45 08             	mov    0x8(%ebp),%eax
773011a3:	89 4c 24 08          	mov    %ecx,0x8(%esp)
773011a7:	89 54 24 04          	mov    %edx,0x4(%esp)
773011ab:	89 04 24             	mov    %eax,(%esp)
773011ae:	e8 4d 6d 00 00       	call   77307f00 <___dllonexit>
773011b3:	c9                   	leave  
773011b4:	c3                   	ret    
773011b5:	90                   	nop    
773011b6:	90                   	nop    
773011b7:	90                   	nop    
773011b8:	90                   	nop    
773011b9:	90                   	nop    
773011ba:	90                   	nop    
773011bb:	90                   	nop    
773011bc:	90                   	nop    
773011bd:	90                   	nop    
773011be:	90                   	nop    
773011bf:	90                   	nop    

773011c0 <___do_sjlj_init>:
773011c0:	55                   	push   %ebp
773011c1:	89 e5                	mov    %esp,%ebp
773011c3:	5d                   	pop    %ebp
773011c4:	e9 a7 6a 00 00       	jmp    77307c70 <___w32_sharedptr_initialize>
773011c9:	90                   	nop    
773011ca:	90                   	nop    
773011cb:	90                   	nop    
773011cc:	90                   	nop    
773011cd:	90                   	nop    
773011ce:	90                   	nop    
773011cf:	90                   	nop    

773011d0 <_interfaceMapInit>:
 * not add any mutex or critical section blockers to these functions.  I've
 * encountered far too many windows functions that contribute to deadlock
 * by not announcing themselves. */
void interfaceMapInit(void)
{
773011d0:	55                   	push   %ebp
773011d1:	89 e5                	mov    %esp,%ebp
773011d3:	5d                   	pop    %ebp
773011d4:	c3                   	ret    
773011d5:	8d 74 26 00          	lea    0x0(%esi),%esi
773011d9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

773011e0 <_interfaceMapFree>:
    /* For now, nothing */
}

void interfaceMapFree(void)
{
773011e0:	55                   	push   %ebp
773011e1:	89 e5                	mov    %esp,%ebp
773011e3:	5d                   	pop    %ebp
773011e4:	c3                   	ret    
773011e5:	8d 74 26 00          	lea    0x0(%esi),%esi
773011e9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

773011f0 <_openTcpFile>:
    /* Ditto. */
}

NTSTATUS openTcpFile(PHANDLE tcpFile) {
773011f0:	55                   	push   %ebp
773011f1:	89 e5                	mov    %esp,%ebp
773011f3:	53                   	push   %ebx
773011f4:	83 ec 3c             	sub    $0x3c,%esp
    UNICODE_STRING fileName;
    OBJECT_ATTRIBUTES objectAttributes;
    IO_STATUS_BLOCK ioStatusBlock;
    NTSTATUS status;

    TRACE("called.\n");

    /* Shamelessly ripped from CreateFileW */
    RtlInitUnicodeString( &fileName, TcpFileName );
773011f7:	8d 5d d0             	lea    0xffffffd0(%ebp),%ebx
773011fa:	68 00 a0 30 77       	push   $0x7730a000
773011ff:	53                   	push   %ebx
77301200:	ff 15 f8 e1 30 77    	call   *0x7730e1f8

    InitializeObjectAttributes( &objectAttributes,
                                &fileName,
                                OBJ_CASE_INSENSITIVE,
                                NULL,
                                NULL );

    status = ZwCreateFile( tcpFile,
77301206:	8d 45 c8             	lea    0xffffffc8(%ebp),%eax
77301209:	89 5d e0             	mov    %ebx,0xffffffe0(%ebp)
7730120c:	c7 45 d8 18 00 00 00 	movl   $0x18,0xffffffd8(%ebp)
77301213:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
7730121a:	6a 00                	push   $0x0
7730121c:	6a 20                	push   $0x20
7730121e:	6a 03                	push   $0x3
77301220:	6a 03                	push   $0x3
77301222:	68 80 00 00 00       	push   $0x80
77301227:	6a 00                	push   $0x0
77301229:	50                   	push   %eax
7730122a:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
7730122d:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
77301234:	50                   	push   %eax
77301235:	c7 45 e4 40 00 00 00 	movl   $0x40,0xffffffe4(%ebp)
7730123c:	8b 45 08             	mov    0x8(%ebp),%eax
7730123f:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
77301246:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
7730124d:	68 00 00 10 20       	push   $0x20100000
77301252:	50                   	push   %eax
77301253:	ff 15 0c e2 30 77    	call   *0x7730e20c
                           SYNCHRONIZE | GENERIC_EXECUTE,
                           &objectAttributes,
                           &ioStatusBlock,
                           NULL,
                           FILE_ATTRIBUTE_NORMAL,
                           FILE_SHARE_READ | FILE_SHARE_WRITE,
                           FILE_OPEN_IF,
                           FILE_SYNCHRONOUS_IO_NONALERT,
                           0,
                           0 );

    /* String does not need to be freed: it points to the constant
     * string we provided */

    TRACE("returning %08x\n", (int)status);

    return status;
}
77301259:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
7730125c:	c9                   	leave  
7730125d:	c3                   	ret    
7730125e:	89 f6                	mov    %esi,%esi

77301260 <_closeTcpFile>:

void closeTcpFile( HANDLE h ) {
77301260:	55                   	push   %ebp
77301261:	89 e5                	mov    %esp,%ebp
77301263:	83 ec 14             	sub    $0x14,%esp
    TRACE("called.\n");
    NtClose( h );
77301266:	8b 55 08             	mov    0x8(%ebp),%edx
77301269:	52                   	push   %edx
7730126a:	ff 15 ec e1 30 77    	call   *0x7730e1ec
77301270:	c9                   	leave  
77301271:	c3                   	ret    
77301272:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
77301279:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77301280 <_tdiGetSetOfThings>:
}

/* A generic thing-getting function which interacts in the right way with
 * TDI.  This may seem oblique, but I'm using it to reduce code and hopefully
 * make this thing easier to debug.
 *
 * The things returned can be any of:
 *   TDIEntityID
 *   TDIObjectID
 *   IFEntry
 *   IPSNMPInfo
 *   IPAddrEntry
 *   IPInterfaceInfo
 */
NTSTATUS tdiGetSetOfThings( HANDLE tcpFile, 
                            DWORD toiClass,
                            DWORD toiType,
                            DWORD toiId,
                            DWORD teiEntity,
                            DWORD fixedPart,
                            DWORD entrySize,
                            PVOID *tdiEntitySet,
                            PDWORD numEntries ) {
77301280:	55                   	push   %ebp
    TCP_REQUEST_QUERY_INFORMATION_EX req = TCP_REQUEST_QUERY_INFORMATION_INIT;
77301281:	31 c0                	xor    %eax,%eax
77301283:	89 e5                	mov    %esp,%ebp
77301285:	b9 09 00 00 00       	mov    $0x9,%ecx
7730128a:	fc                   	cld    
7730128b:	57                   	push   %edi
7730128c:	8d 7d b8             	lea    0xffffffb8(%ebp),%edi
7730128f:	56                   	push   %esi
77301290:	53                   	push   %ebx
77301291:	83 ec 4c             	sub    $0x4c,%esp
77301294:	f3 ab                	repz stos %eax,%es:(%edi)
    PVOID entitySet = 0;
    NTSTATUS status = STATUS_SUCCESS;
    DWORD allocationSizeForEntityArray = entrySize * MAX_TDI_ENTITIES, 
77301296:	8b 45 20             	mov    0x20(%ebp),%eax
77301299:	8b 5d 0c             	mov    0xc(%ebp),%ebx
7730129c:	c1 e0 0c             	shl    $0xc,%eax
7730129f:	8b 75 10             	mov    0x10(%ebp),%esi
773012a2:	89 45 b4             	mov    %eax,0xffffffb4(%ebp)
        arraySize = entrySize * MAX_TDI_ENTITIES;

    DbgPrint("TdiGetSetOfThings(tcpFile %x,toiClass %x,toiType %x,toiId %x,"
773012a5:	8b 45 20             	mov    0x20(%ebp),%eax
773012a8:	50                   	push   %eax
773012a9:	8b 45 1c             	mov    0x1c(%ebp),%eax
773012ac:	50                   	push   %eax
773012ad:	8b 7d 18             	mov    0x18(%ebp),%edi
773012b0:	57                   	push   %edi
773012b1:	8b 4d 14             	mov    0x14(%ebp),%ecx
773012b4:	51                   	push   %ecx
773012b5:	56                   	push   %esi
773012b6:	53                   	push   %ebx
773012b7:	8b 55 08             	mov    0x8(%ebp),%edx
773012ba:	52                   	push   %edx
773012bb:	68 1c a0 30 77       	push   $0x7730a01c
773012c0:	e8 bb 66 00 00       	call   77307980 <_DbgPrint>
           "teiEntity %x,fixedPart %d,entrySize %d)\n",
           (int)tcpFile, 
           (int)toiClass, 
           (int)toiType, 
           (int)toiId, 
           (int)teiEntity,
           (int)fixedPart, 
           (int)entrySize );

    req.ID.toi_class                = toiClass;
    req.ID.toi_type                 = toiType;
    req.ID.toi_id                   = toiId;
773012c5:	8b 45 14             	mov    0x14(%ebp),%eax
    req.ID.toi_entity.tei_entity    = teiEntity;
773012c8:	8b 55 18             	mov    0x18(%ebp),%edx
773012cb:	89 5d c0             	mov    %ebx,0xffffffc0(%ebp)
773012ce:	89 75 c4             	mov    %esi,0xffffffc4(%ebp)
773012d1:	89 45 c8             	mov    %eax,0xffffffc8(%ebp)
773012d4:	89 55 b8             	mov    %edx,0xffffffb8(%ebp)

    /* There's a subtle problem here...
     * If an interface is added at this exact instant, (as if by a PCMCIA
     * card insertion), the array will still not have enough entries after
     * have allocated it after the first DeviceIoControl call.
     *
     * We'll get around this by repeating until the number of interfaces
     * stabilizes.
     */
    do {
773012d7:	83 c4 20             	add    $0x20,%esp
773012da:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
        ASSERT( !entitySet ); /* We must not have an entity set allocated */
        status = DeviceIoControl( tcpFile,
773012e0:	8d 45 b8             	lea    0xffffffb8(%ebp),%eax
773012e3:	8d 7d b4             	lea    0xffffffb4(%ebp),%edi
773012e6:	6a 00                	push   $0x0
773012e8:	57                   	push   %edi
773012e9:	6a 00                	push   $0x0
773012eb:	6a 00                	push   $0x0
773012ed:	6a 24                	push   $0x24
773012ef:	50                   	push   %eax
773012f0:	68 03 00 12 00       	push   $0x120003
773012f5:	8b 45 08             	mov    0x8(%ebp),%eax
773012f8:	50                   	push   %eax
773012f9:	e8 22 41 00 00       	call   77305420 <_DeviceIoControl@32>
773012fe:	89 c6                	mov    %eax,%esi
                                  IOCTL_TCP_QUERY_INFORMATION_EX,
                                  &req,
                                  sizeof(req),
                                  0,
                                  0,
                                  &allocationSizeForEntityArray,
                                  NULL );

        if( !NT_SUCCESS(status) ) {
77301300:	85 c0                	test   %eax,%eax
77301302:	78 56                	js     7730135a <_tdiGetSetOfThings+0xda>
            return status;
        }
        
        arraySize = allocationSizeForEntityArray;
77301304:	8b 5d b4             	mov    0xffffffb4(%ebp),%ebx
        entitySet = HeapAlloc( GetProcessHeap(), 0, arraySize );
77301307:	50                   	push   %eax
77301308:	53                   	push   %ebx
77301309:	6a 00                	push   $0x0
7730130b:	50                   	push   %eax
7730130c:	e8 1f 41 00 00       	call   77305430 <_GetProcessHeap@0>
77301311:	89 04 24             	mov    %eax,(%esp)
77301314:	e8 27 41 00 00       	call   77305440 <_HeapAlloc@12>
77301319:	89 c7                	mov    %eax,%edi
                                              
        if( !entitySet ) {
7730131b:	58                   	pop    %eax
7730131c:	85 ff                	test   %edi,%edi
7730131e:	74 44                	je     77301364 <_tdiGetSetOfThings+0xe4>
            status = STATUS_INSUFFICIENT_RESOURCES;
            DPRINT("TdiGetSetOfThings() => %08x\n", (int)status);
            return status;
        }

        status = DeviceIoControl( tcpFile,
77301320:	8d 55 b4             	lea    0xffffffb4(%ebp),%edx
77301323:	8d 45 b8             	lea    0xffffffb8(%ebp),%eax
77301326:	6a 00                	push   $0x0
77301328:	52                   	push   %edx
77301329:	53                   	push   %ebx
7730132a:	57                   	push   %edi
7730132b:	6a 24                	push   $0x24
7730132d:	50                   	push   %eax
7730132e:	68 03 00 12 00       	push   $0x120003
77301333:	8b 45 08             	mov    0x8(%ebp),%eax
77301336:	50                   	push   %eax
77301337:	e8 e4 40 00 00       	call   77305420 <_DeviceIoControl@32>
                                  IOCTL_TCP_QUERY_INFORMATION_EX,
                                  &req,
                                  sizeof(req),
                                  entitySet,
                                  arraySize,
                                  &allocationSizeForEntityArray,
                                  NULL );
        
        /* This is why we have the loop -- we might have added an adapter */
        if( arraySize == allocationSizeForEntityArray )
7730133c:	3b 5d b4             	cmp    0xffffffb4(%ebp),%ebx
7730133f:	89 c6                	mov    %eax,%esi
77301341:	74 2e                	je     77301371 <_tdiGetSetOfThings+0xf1>
            break;

        HeapFree( GetProcessHeap(), 0, entitySet );
77301343:	50                   	push   %eax
77301344:	57                   	push   %edi
77301345:	6a 00                	push   $0x0
77301347:	57                   	push   %edi
77301348:	e8 e3 40 00 00       	call   77305430 <_GetProcessHeap@0>
7730134d:	89 04 24             	mov    %eax,(%esp)
77301350:	e8 fb 40 00 00       	call   77305450 <_HeapFree@12>
        entitySet = 0;

        if( !NT_SUCCESS(status) ) {
77301355:	85 f6                	test   %esi,%esi
77301357:	5b                   	pop    %ebx
77301358:	79 86                	jns    773012e0 <_tdiGetSetOfThings+0x60>
            DPRINT("TdiGetSetOfThings() => %08x\n", (int)status);
            return status;
7730135a:	89 f0                	mov    %esi,%eax
        }

        DPRINT("TdiGetSetOfThings(): Array changed size: %d -> %d.\n",
               arraySize, allocationSizeForEntityArray );
    } while( TRUE ); /* We break if the array we received was the size we 
                      * expected.  Therefore, we got here because it wasn't */
    
    *numEntries = (arraySize - fixedPart) / entrySize;
    *tdiEntitySet = entitySet;

    DPRINT("TdiGetSetOfThings() => Success: %d things @ %08x\n", 
           (int)*numEntries, (int)entitySet);

    return STATUS_SUCCESS;
}
7730135c:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
7730135f:	5b                   	pop    %ebx
77301360:	5e                   	pop    %esi
77301361:	5f                   	pop    %edi
77301362:	5d                   	pop    %ebp
77301363:	c3                   	ret    
77301364:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77301367:	b8 9a 00 00 c0       	mov    $0xc000009a,%eax
7730136c:	5b                   	pop    %ebx
7730136d:	5e                   	pop    %esi
7730136e:	5f                   	pop    %edi
7730136f:	5d                   	pop    %ebp
77301370:	c3                   	ret    
77301371:	8b 4d 1c             	mov    0x1c(%ebp),%ecx
77301374:	31 d2                	xor    %edx,%edx
77301376:	29 cb                	sub    %ecx,%ebx
77301378:	89 d8                	mov    %ebx,%eax
7730137a:	f7 75 20             	divl   0x20(%ebp)
7730137d:	89 c1                	mov    %eax,%ecx
7730137f:	8b 45 28             	mov    0x28(%ebp),%eax
77301382:	89 08                	mov    %ecx,(%eax)
77301384:	8b 45 24             	mov    0x24(%ebp),%eax
77301387:	89 38                	mov    %edi,(%eax)
77301389:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
7730138c:	31 c0                	xor    %eax,%eax
7730138e:	5b                   	pop    %ebx
7730138f:	5e                   	pop    %esi
77301390:	5f                   	pop    %edi
77301391:	5d                   	pop    %ebp
77301392:	c3                   	ret    
77301393:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77301399:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

773013a0 <_tdiFreeThingSet>:

VOID tdiFreeThingSet( PVOID things ) {
773013a0:	55                   	push   %ebp
773013a1:	89 e5                	mov    %esp,%ebp
773013a3:	83 ec 0c             	sub    $0xc,%esp
    HeapFree( GetProcessHeap(), 0, things );
773013a6:	8b 45 08             	mov    0x8(%ebp),%eax
773013a9:	50                   	push   %eax
773013aa:	6a 00                	push   $0x0
773013ac:	50                   	push   %eax
773013ad:	e8 7e 40 00 00       	call   77305430 <_GetProcessHeap@0>
773013b2:	89 04 24             	mov    %eax,(%esp)
773013b5:	e8 96 40 00 00       	call   77305450 <_HeapFree@12>
773013ba:	c9                   	leave  
773013bb:	c3                   	ret    
773013bc:	8d 74 26 00          	lea    0x0(%esi),%esi

773013c0 <_tdiGetMibForIfEntity>:
}

NTSTATUS tdiGetMibForIfEntity
( HANDLE tcpFile, TDIEntityID *ent, IFEntrySafelySized *entry ) {
773013c0:	55                   	push   %ebp
    TCP_REQUEST_QUERY_INFORMATION_EX req = TCP_REQUEST_QUERY_INFORMATION_INIT;
773013c1:	31 c0                	xor    %eax,%eax
773013c3:	89 e5                	mov    %esp,%ebp
773013c5:	b9 09 00 00 00       	mov    $0x9,%ecx
773013ca:	fc                   	cld    
773013cb:	57                   	push   %edi
773013cc:	8d 7d c8             	lea    0xffffffc8(%ebp),%edi
773013cf:	83 ec 44             	sub    $0x44,%esp
773013d2:	f3 ab                	repz stos %eax,%es:(%edi)
    NTSTATUS status = STATUS_SUCCESS;
    DWORD returnSize;

    DPRINT("TdiGetMibForIfEntity(tcpFile %x,entityId %x)\n",
           (int)tcpFile, (int)ent->tei_instance);

    req.ID.toi_class                = INFO_CLASS_PROTOCOL;
    req.ID.toi_type                 = INFO_TYPE_PROVIDER;
    req.ID.toi_id                   = IF_MIB_STATS_ID;
    req.ID.toi_entity               = *ent;
773013d4:	8b 45 0c             	mov    0xc(%ebp),%eax
773013d7:	c7 45 d0 00 02 00 00 	movl   $0x200,0xffffffd0(%ebp)
773013de:	c7 45 d4 00 01 00 00 	movl   $0x100,0xffffffd4(%ebp)
773013e5:	c7 45 d8 01 00 00 00 	movl   $0x1,0xffffffd8(%ebp)
773013ec:	8b 50 04             	mov    0x4(%eax),%edx
773013ef:	8b 00                	mov    (%eax),%eax
773013f1:	89 45 c8             	mov    %eax,0xffffffc8(%ebp)

    status = DeviceIoControl( tcpFile,
773013f4:	8d 45 c4             	lea    0xffffffc4(%ebp),%eax
773013f7:	6a 00                	push   $0x0
773013f9:	50                   	push   %eax
773013fa:	8b 45 10             	mov    0x10(%ebp),%eax
773013fd:	68 e8 00 00 00       	push   $0xe8
77301402:	50                   	push   %eax
77301403:	8d 45 c8             	lea    0xffffffc8(%ebp),%eax
77301406:	6a 24                	push   $0x24
77301408:	50                   	push   %eax
77301409:	8b 45 08             	mov    0x8(%ebp),%eax
7730140c:	89 55 cc             	mov    %edx,0xffffffcc(%ebp)
7730140f:	68 03 00 12 00       	push   $0x120003
77301414:	50                   	push   %eax
77301415:	e8 06 40 00 00       	call   77305420 <_DeviceIoControl@32>
                              IOCTL_TCP_QUERY_INFORMATION_EX,
                              &req,
                              sizeof(req),
                              entry,
                              sizeof(*entry),
                              &returnSize,
                              NULL );

    if( !NT_SUCCESS(status) ) {
        TRACE("failure: %08x\n", status);
        return status;
    } else TRACE("Success.\n");

    DPRINT("TdiGetMibForIfEntity() => {\n"
           "  if_index ....................... %x\n"
           "  if_type ........................ %x\n"
           "  if_mtu ......................... %d\n"
           "  if_speed ....................... %x\n"
           "  if_physaddrlen ................. %d\n",
           entry->ent.if_index,
           entry->ent.if_type,
           entry->ent.if_mtu,
           entry->ent.if_speed,
           entry->ent.if_physaddrlen);
    DPRINT("  if_physaddr .................... %02x:%02x:%02x:%02x:%02x:%02x\n",
           "  if_descr ....................... %s\n",
           entry->ent.if_physaddr[0] & 0xff,
           entry->ent.if_physaddr[1] & 0xff,
           entry->ent.if_physaddr[2] & 0xff,
           entry->ent.if_physaddr[3] & 0xff,
           entry->ent.if_physaddr[4] & 0xff,
           entry->ent.if_physaddr[5] & 0xff,
           entry->ent.if_descr);
    DPRINT("} status %08x\n",status);
        
    return status;    
}
7730141a:	8b 7d fc             	mov    0xfffffffc(%ebp),%edi
7730141d:	c9                   	leave  
7730141e:	c3                   	ret    
7730141f:	90                   	nop    

77301420 <_tdiGetEntityIDSet>:

NTSTATUS tdiGetEntityIDSet( HANDLE tcpFile,
                            TDIEntityID **entitySet, 
                            PDWORD numEntities ) {
77301420:	55                   	push   %ebp
77301421:	89 e5                	mov    %esp,%ebp
77301423:	53                   	push   %ebx
77301424:	83 ec 10             	sub    $0x10,%esp
77301427:	8b 5d 10             	mov    0x10(%ebp),%ebx
    NTSTATUS status = tdiGetSetOfThings( tcpFile,
7730142a:	8b 4d 0c             	mov    0xc(%ebp),%ecx
7730142d:	8b 55 08             	mov    0x8(%ebp),%edx
77301430:	53                   	push   %ebx
77301431:	51                   	push   %ecx
77301432:	6a 08                	push   $0x8
77301434:	6a 00                	push   $0x0
77301436:	6a 00                	push   $0x0
77301438:	6a 00                	push   $0x0
7730143a:	68 00 01 00 00       	push   $0x100
7730143f:	68 00 01 00 00       	push   $0x100
77301444:	52                   	push   %edx
77301445:	e8 36 fe ff ff       	call   77301280 <_tdiGetSetOfThings>
                                         INFO_CLASS_GENERIC,
                                         INFO_TYPE_PROVIDER,
                                         ENTITY_LIST_ID,
                                         GENERIC_ENTITY,
                                         0,
                                         sizeof(TDIEntityID),
                                         (PVOID *)entitySet,
                                         numEntities );
    if( NT_SUCCESS(status) ) {
7730144a:	83 c4 30             	add    $0x30,%esp
7730144d:	85 c0                	test   %eax,%eax
7730144f:	78 09                	js     7730145a <_tdiGetEntityIDSet+0x3a>
        int i;

        for( i = 0; i < *numEntities; i++ ) {
77301451:	8b 13                	mov    (%ebx),%edx
77301453:	85 d2                	test   %edx,%edx
77301455:	eb 01                	jmp    77301458 <_tdiGetEntityIDSet+0x38>
77301457:	4a                   	dec    %edx
77301458:	75 fd                	jne    77301457 <_tdiGetEntityIDSet+0x37>
            DPRINT("%-4d: %04x:%08x\n",
                   i,
                   (*entitySet)[i].tei_entity, 
                   (*entitySet)[i].tei_instance );
        }
    }
    
    return status;
}
7730145a:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
7730145d:	c9                   	leave  
7730145e:	c3                   	ret    
7730145f:	90                   	nop    

77301460 <_isInterface>:

static BOOL isInterface( TDIEntityID *if_maybe ) {
77301460:	55                   	push   %ebp
    return 
77301461:	81 38 00 02 00 00    	cmpl   $0x200,(%eax)
77301467:	89 e5                	mov    %esp,%ebp
77301469:	0f 94 c0             	sete   %al
7730146c:	25 ff 00 00 00       	and    $0xff,%eax
        if_maybe->tei_entity == IF_ENTITY;
}
77301471:	5d                   	pop    %ebp
77301472:	c3                   	ret    
77301473:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77301479:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77301480 <_isLoopback>:

static BOOL isLoopback( HANDLE tcpFile, TDIEntityID *loop_maybe ) {
77301480:	55                   	push   %ebp
77301481:	89 e5                	mov    %esp,%ebp
77301483:	81 ec fc 00 00 00    	sub    $0xfc,%esp
    IFEntrySafelySized entryInfo;

    tdiGetMibForIfEntity( tcpFile, 
77301489:	8d 8d 08 ff ff ff    	lea    0xffffff08(%ebp),%ecx
7730148f:	51                   	push   %ecx
77301490:	52                   	push   %edx
77301491:	50                   	push   %eax
77301492:	e8 29 ff ff ff       	call   773013c0 <_tdiGetMibForIfEntity>
                          loop_maybe,
                          &entryInfo );

    return !entryInfo.ent.if_type || 
77301497:	8b 85 0c ff ff ff    	mov    0xffffff0c(%ebp),%eax
7730149d:	83 c4 10             	add    $0x10,%esp
773014a0:	85 c0                	test   %eax,%eax
        entryInfo.ent.if_type == IFENT_SOFTWARE_LOOPBACK;
}
773014a2:	c9                   	leave  
773014a3:	0f 94 c2             	sete   %dl
773014a6:	83 f8 18             	cmp    $0x18,%eax
773014a9:	0f 94 c0             	sete   %al
773014ac:	09 d0                	or     %edx,%eax
773014ae:	83 e0 01             	and    $0x1,%eax
773014b1:	c3                   	ret    
773014b2:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
773014b9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

773014c0 <_tdiGetEntityType>:

NTSTATUS tdiGetEntityType( HANDLE tcpFile, TDIEntityID *ent, PULONG type ) {
773014c0:	55                   	push   %ebp
    TCP_REQUEST_QUERY_INFORMATION_EX req = TCP_REQUEST_QUERY_INFORMATION_INIT;
773014c1:	31 c0                	xor    %eax,%eax
773014c3:	89 e5                	mov    %esp,%ebp
773014c5:	b9 09 00 00 00       	mov    $0x9,%ecx
773014ca:	fc                   	cld    
773014cb:	57                   	push   %edi
773014cc:	8d 7d c8             	lea    0xffffffc8(%ebp),%edi
773014cf:	83 ec 44             	sub    $0x44,%esp
773014d2:	f3 ab                	repz stos %eax,%es:(%edi)
773014d4:	8b 55 0c             	mov    0xc(%ebp),%edx
    NTSTATUS status = STATUS_SUCCESS;
    DWORD returnSize;

    DPRINT("TdiGetEntityType(tcpFile %x,entityId %x)\n",
           (DWORD)tcpFile, ent->tei_instance);

    req.ID.toi_class                = INFO_CLASS_GENERIC;
773014d7:	c7 45 d0 00 01 00 00 	movl   $0x100,0xffffffd0(%ebp)
    req.ID.toi_type                 = INFO_TYPE_PROVIDER;
773014de:	c7 45 d4 00 01 00 00 	movl   $0x100,0xffffffd4(%ebp)
    req.ID.toi_id                   = ENTITY_TYPE_ID;
773014e5:	c7 45 d8 01 00 00 00 	movl   $0x1,0xffffffd8(%ebp)
    req.ID.toi_entity.tei_entity    = ent->tei_entity;
773014ec:	8b 02                	mov    (%edx),%eax
    req.ID.toi_entity.tei_instance  = ent->tei_instance;

    status = DeviceIoControl( tcpFile,
773014ee:	8b 7d 08             	mov    0x8(%ebp),%edi
773014f1:	89 45 c8             	mov    %eax,0xffffffc8(%ebp)
773014f4:	8b 42 04             	mov    0x4(%edx),%eax
773014f7:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
773014fa:	8d 45 c4             	lea    0xffffffc4(%ebp),%eax
773014fd:	6a 00                	push   $0x0
773014ff:	50                   	push   %eax
77301500:	8b 45 10             	mov    0x10(%ebp),%eax
77301503:	6a 04                	push   $0x4
77301505:	50                   	push   %eax
77301506:	8d 45 c8             	lea    0xffffffc8(%ebp),%eax
77301509:	6a 24                	push   $0x24
7730150b:	50                   	push   %eax
7730150c:	68 03 00 12 00       	push   $0x120003
77301511:	57                   	push   %edi
77301512:	e8 09 3f 00 00       	call   77305420 <_DeviceIoControl@32>
                              IOCTL_TCP_QUERY_INFORMATION_EX,
                              &req,
                              sizeof(req),
                              type,
                              sizeof(*type),
                              &returnSize,
                              NULL );

    DPRINT("TdiGetEntityType() => %08x %08x\n", *type, status);

    return status;
}
77301517:	8b 7d fc             	mov    0xfffffffc(%ebp),%edi
7730151a:	c9                   	leave  
7730151b:	c3                   	ret    
7730151c:	8d 74 26 00          	lea    0x0(%esi),%esi

77301520 <_getInterfaceInfoSet>:

static NTSTATUS getInterfaceInfoSet( HANDLE tcpFile, 
                                     IFInfo **infoSet,
                                     PDWORD numInterfaces ) {
77301520:	55                   	push   %ebp
77301521:	89 e5                	mov    %esp,%ebp
77301523:	57                   	push   %edi
77301524:	56                   	push   %esi
77301525:	53                   	push   %ebx
77301526:	83 ec 50             	sub    $0x50,%esp
77301529:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
    DWORD numEntities;
    TDIEntityID *entIDSet = 0;
    NTSTATUS status = tdiGetEntityIDSet( tcpFile, &entIDSet, &numEntities );
7730152c:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
7730152f:	8b 75 d4             	mov    0xffffffd4(%ebp),%esi
77301532:	50                   	push   %eax
77301533:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
77301536:	50                   	push   %eax
77301537:	89 55 d0             	mov    %edx,0xffffffd0(%ebp)
7730153a:	56                   	push   %esi
7730153b:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
77301542:	e8 d9 fe ff ff       	call   77301420 <_tdiGetEntityIDSet>
    IFInfo *infoSetInt = 0;
    BOOL interfaceInfoComplete;
    int curInterf = 0, i;

    if( NT_SUCCESS(status) )
77301547:	83 c4 10             	add    $0x10,%esp
7730154a:	c7 45 cc 00 00 00 00 	movl   $0x0,0xffffffcc(%ebp)
77301551:	c7 45 c8 00 00 00 00 	movl   $0x0,0xffffffc8(%ebp)
77301558:	85 c0                	test   %eax,%eax
7730155a:	0f 88 18 01 00 00    	js     77301678 <_getInterfaceInfoSet+0x158>
        infoSetInt = HeapAlloc( GetProcessHeap(), 0, 
77301560:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
77301563:	89 c2                	mov    %eax,%edx
77301565:	53                   	push   %ebx
77301566:	c1 e2 05             	shl    $0x5,%edx
77301569:	01 c2                	add    %eax,%edx
7730156b:	8d 14 50             	lea    (%eax,%edx,2),%edx
7730156e:	c1 e2 02             	shl    $0x2,%edx
77301571:	52                   	push   %edx
77301572:	6a 00                	push   $0x0
77301574:	51                   	push   %ecx
77301575:	e8 b6 3e 00 00       	call   77305430 <_GetProcessHeap@0>
7730157a:	89 04 24             	mov    %eax,(%esp)
7730157d:	e8 be 3e 00 00       	call   77305440 <_HeapAlloc@12>
77301582:	5a                   	pop    %edx
                                sizeof(IFInfo) * numEntities );
    
    if( infoSetInt ) {
77301583:	85 c0                	test   %eax,%eax
77301585:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
77301588:	0f 84 ea 00 00 00    	je     77301678 <_getInterfaceInfoSet+0x158>
        for( i = 0; i < numEntities; i++ ) {
7730158e:	8b 75 ec             	mov    0xffffffec(%ebp),%esi
77301591:	c7 45 c4 00 00 00 00 	movl   $0x0,0xffffffc4(%ebp)
77301598:	39 75 c8             	cmp    %esi,0xffffffc8(%ebp)
7730159b:	0f 83 d7 00 00 00    	jae    77301678 <_getInterfaceInfoSet+0x158>
773015a1:	83 c0 08             	add    $0x8,%eax
773015a4:	c7 45 b8 00 00 00 00 	movl   $0x0,0xffffffb8(%ebp)
773015ab:	89 45 b4             	mov    %eax,0xffffffb4(%ebp)
773015ae:	eb 10                	jmp    773015c0 <_getInterfaceInfoSet+0xa0>
773015b0:	8b 45 c4             	mov    0xffffffc4(%ebp),%eax
773015b3:	40                   	inc    %eax
773015b4:	89 45 c4             	mov    %eax,0xffffffc4(%ebp)
773015b7:	39 75 c4             	cmp    %esi,0xffffffc4(%ebp)
773015ba:	0f 83 b8 00 00 00    	jae    77301678 <_getInterfaceInfoSet+0x158>
            if( isInterface( &entIDSet[i] ) ) {
773015c0:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
773015c3:	8b 55 c4             	mov    0xffffffc4(%ebp),%edx
773015c6:	8d 1c d0             	lea    (%eax,%edx,8),%ebx
773015c9:	89 d8                	mov    %ebx,%eax
773015cb:	e8 90 fe ff ff       	call   77301460 <_isInterface>
773015d0:	85 c0                	test   %eax,%eax
773015d2:	74 dc                	je     773015b0 <_getInterfaceInfoSet+0x90>
                status = tdiGetMibForIfEntity
773015d4:	8b 7d b4             	mov    0xffffffb4(%ebp),%edi
773015d7:	8b 75 d4             	mov    0xffffffd4(%ebp),%esi
773015da:	50                   	push   %eax
773015db:	57                   	push   %edi
773015dc:	53                   	push   %ebx
773015dd:	56                   	push   %esi
773015de:	e8 dd fd ff ff       	call   773013c0 <_tdiGetMibForIfEntity>
                    ( tcpFile,
                      &entIDSet[i],
                      &infoSetInt[curInterf].if_info );
		DPRINT("tdiGetMibForIfEntity: %08x\n", status);
                if( NT_SUCCESS(status) ) {
773015e3:	83 c4 10             	add    $0x10,%esp
773015e6:	85 c0                	test   %eax,%eax
773015e8:	78 7b                	js     77301665 <_getInterfaceInfoSet+0x145>
                    DWORD numAddrs;
                    IPAddrEntry *addrs;
                    TDIEntityID ip_ent;
                    int j,k;

                    interfaceInfoComplete = FALSE;
		    status = getNthIpEntity( tcpFile, 0, &ip_ent );
773015ea:	8d 4d e0             	lea    0xffffffe0(%ebp),%ecx
773015ed:	53                   	push   %ebx
773015ee:	51                   	push   %ecx
773015ef:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
773015f2:	6a 00                	push   $0x0
773015f4:	51                   	push   %ecx
773015f5:	e8 e6 0a 00 00       	call   773020e0 <_getNthIpEntity>
		    if( NT_SUCCESS(status) )
773015fa:	83 c4 10             	add    $0x10,%esp
773015fd:	89 c2                	mov    %eax,%edx
773015ff:	85 c0                	test   %eax,%eax
77301601:	78 1a                	js     7730161d <_getInterfaceInfoSet+0xfd>
			status = tdiGetIpAddrsForIpEntity
77301603:	8d 45 dc             	lea    0xffffffdc(%ebp),%eax
77301606:	8b 55 d4             	mov    0xffffffd4(%ebp),%edx
77301609:	50                   	push   %eax
7730160a:	8d 5d e0             	lea    0xffffffe0(%ebp),%ebx
7730160d:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
77301610:	50                   	push   %eax
77301611:	53                   	push   %ebx
77301612:	52                   	push   %edx
77301613:	e8 28 0c 00 00       	call   77302240 <_tdiGetIpAddrsForIpEntity>
77301618:	83 c4 10             	add    $0x10,%esp
7730161b:	89 c2                	mov    %eax,%edx
			    ( tcpFile, &ip_ent, &addrs, &numAddrs );
		    for( k = 0; k < numAddrs && NT_SUCCESS(status); k++ ) {
7730161d:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
77301620:	31 db                	xor    %ebx,%ebx
77301622:	39 c3                	cmp    %eax,%ebx
77301624:	89 45 bc             	mov    %eax,0xffffffbc(%ebp)
77301627:	0f 92 c0             	setb   %al
7730162a:	83 f2 ff             	xor    $0xffffffff,%edx
7730162d:	c1 ea 1f             	shr    $0x1f,%edx
77301630:	89 55 ac             	mov    %edx,0xffffffac(%ebp)
77301633:	85 d0                	test   %edx,%eax
77301635:	74 2e                	je     77301665 <_getInterfaceInfoSet+0x145>
77301637:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
7730163a:	8b 4d b8             	mov    0xffffffb8(%ebp),%ecx
7730163d:	8b 45 cc             	mov    0xffffffcc(%ebp),%eax
77301640:	89 55 c0             	mov    %edx,0xffffffc0(%ebp)
77301643:	31 f6                	xor    %esi,%esi
77301645:	83 c2 04             	add    $0x4,%edx
77301648:	8b 7c 01 08          	mov    0x8(%ecx,%eax,1),%edi
7730164c:	8b 4d ac             	mov    0xffffffac(%ebp),%ecx
7730164f:	90                   	nop    
			DPRINT("ADDR %d: index %d (target %d)\n", k, addrs[k].iae_index, infoSetInt[curInterf].if_info.ent.if_index);
			if( addrs[k].iae_index == 
77301650:	39 3a                	cmp    %edi,(%edx)
77301652:	74 3e                	je     77301692 <_getInterfaceInfoSet+0x172>
77301654:	43                   	inc    %ebx
77301655:	83 c6 1c             	add    $0x1c,%esi
77301658:	83 c2 1c             	add    $0x1c,%edx
7730165b:	3b 5d bc             	cmp    0xffffffbc(%ebp),%ebx
7730165e:	0f 92 c0             	setb   %al
77301661:	85 c8                	test   %ecx,%eax
77301663:	75 eb                	jne    77301650 <_getInterfaceInfoSet+0x130>
77301665:	8b 75 ec             	mov    0xffffffec(%ebp),%esi
77301668:	8b 45 c4             	mov    0xffffffc4(%ebp),%eax
7730166b:	40                   	inc    %eax
7730166c:	89 45 c4             	mov    %eax,0xffffffc4(%ebp)
7730166f:	39 75 c4             	cmp    %esi,0xffffffc4(%ebp)
77301672:	0f 82 48 ff ff ff    	jb     773015c0 <_getInterfaceInfoSet+0xa0>
			    infoSetInt[curInterf].if_info.ent.if_index ) {
			    memcpy( &infoSetInt[curInterf].ip_addr,
				    &addrs[k],
				    sizeof( addrs[k] ) );
			    curInterf++;
			    break;
			}
		    }
                }
            }
        }
    }

    *infoSet = infoSetInt;
77301678:	8b 45 d0             	mov    0xffffffd0(%ebp),%eax
7730167b:	8b 55 cc             	mov    0xffffffcc(%ebp),%edx
    *numInterfaces = curInterf;
7730167e:	8b 4d c8             	mov    0xffffffc8(%ebp),%ecx
77301681:	89 10                	mov    %edx,(%eax)
77301683:	8b 45 08             	mov    0x8(%ebp),%eax
77301686:	89 08                	mov    %ecx,(%eax)

    return STATUS_SUCCESS;
}
77301688:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
7730168b:	31 c0                	xor    %eax,%eax
7730168d:	5b                   	pop    %ebx
7730168e:	5e                   	pop    %esi
7730168f:	5f                   	pop    %edi
77301690:	5d                   	pop    %ebp
77301691:	c3                   	ret    
77301692:	8b 5d c0             	mov    0xffffffc0(%ebp),%ebx
77301695:	8b 55 b8             	mov    0xffffffb8(%ebp),%edx
77301698:	8b 45 cc             	mov    0xffffffcc(%ebp),%eax
7730169b:	01 c2                	add    %eax,%edx
7730169d:	8b 04 1e             	mov    (%esi,%ebx,1),%eax
773016a0:	89 82 f0 00 00 00    	mov    %eax,0xf0(%edx)
773016a6:	8d 8a f0 00 00 00    	lea    0xf0(%edx),%ecx
773016ac:	8b 44 1e 04          	mov    0x4(%esi,%ebx,1),%eax
773016b0:	89 41 04             	mov    %eax,0x4(%ecx)
773016b3:	8b 44 1e 08          	mov    0x8(%esi,%ebx,1),%eax
773016b7:	89 41 08             	mov    %eax,0x8(%ecx)
773016ba:	8b 44 1e 0c          	mov    0xc(%esi,%ebx,1),%eax
773016be:	89 41 0c             	mov    %eax,0xc(%ecx)
773016c1:	8b 44 1e 10          	mov    0x10(%esi,%ebx,1),%eax
773016c5:	89 41 10             	mov    %eax,0x10(%ecx)
773016c8:	8b 44 1e 14          	mov    0x14(%esi,%ebx,1),%eax
773016cc:	89 41 14             	mov    %eax,0x14(%ecx)
773016cf:	8b 44 1e 18          	mov    0x18(%esi,%ebx,1),%eax
773016d3:	89 41 18             	mov    %eax,0x18(%ecx)
773016d6:	8b 45 c8             	mov    0xffffffc8(%ebp),%eax
773016d9:	8b 75 ec             	mov    0xffffffec(%ebp),%esi
773016dc:	40                   	inc    %eax
773016dd:	89 45 c8             	mov    %eax,0xffffffc8(%ebp)
773016e0:	8b 45 b4             	mov    0xffffffb4(%ebp),%eax
773016e3:	05 0c 01 00 00       	add    $0x10c,%eax
773016e8:	89 45 b4             	mov    %eax,0xffffffb4(%ebp)
773016eb:	8b 45 b8             	mov    0xffffffb8(%ebp),%eax
773016ee:	05 0c 01 00 00       	add    $0x10c,%eax
773016f3:	89 45 b8             	mov    %eax,0xffffffb8(%ebp)
773016f6:	e9 6d ff ff ff       	jmp    77301668 <_getInterfaceInfoSet+0x148>
773016fb:	90                   	nop    
773016fc:	8d 74 26 00          	lea    0x0(%esi),%esi

77301700 <_getNumInterfacesInt>:

static DWORD getNumInterfacesInt(BOOL onlyNonLoopback)
{
77301700:	55                   	push   %ebp
77301701:	89 e5                	mov    %esp,%ebp
77301703:	57                   	push   %edi
77301704:	56                   	push   %esi
77301705:	53                   	push   %ebx
77301706:	83 ec 28             	sub    $0x28,%esp
77301709:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
    DWORD numEntities, numInterfaces = 0;
    TDIEntityID *entitySet;
    HANDLE tcpFile;
    NTSTATUS status;
    int i;

    status = openTcpFile( &tcpFile );
7730170c:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
7730170f:	c7 45 e0 00 00 00 00 	movl   $0x0,0xffffffe0(%ebp)
77301716:	50                   	push   %eax
77301717:	e8 d4 fa ff ff       	call   773011f0 <_openTcpFile>

    if( !NT_SUCCESS(status) ) {
7730171c:	83 c4 10             	add    $0x10,%esp
        DPRINT("getNumInterfaces: failed %08x\n", status );
        return 0;
7730171f:	31 d2                	xor    %edx,%edx
77301721:	85 c0                	test   %eax,%eax
77301723:	78 6e                	js     77301793 <_getNumInterfacesInt+0x93>
    }

    status = tdiGetEntityIDSet( tcpFile, &entitySet, &numEntities );
77301725:	50                   	push   %eax
77301726:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
77301729:	50                   	push   %eax
7730172a:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
7730172d:	50                   	push   %eax
7730172e:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
77301731:	50                   	push   %eax
77301732:	e8 e9 fc ff ff       	call   77301420 <_tdiGetEntityIDSet>

    if( !NT_SUCCESS(status) ) {
77301737:	83 c4 10             	add    $0x10,%esp
        DPRINT("getNumInterfaces: failed %08x\n", status );
        return 0;
7730173a:	31 d2                	xor    %edx,%edx
7730173c:	85 c0                	test   %eax,%eax
7730173e:	78 53                	js     77301793 <_getNumInterfacesInt+0x93>
    }

    closeTcpFile( tcpFile );
77301740:	83 ec 0c             	sub    $0xc,%esp
77301743:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax

    for( i = 0; i < numEntities; i++ ) {
77301746:	31 ff                	xor    %edi,%edi
77301748:	50                   	push   %eax
77301749:	e8 12 fb ff ff       	call   77301260 <_closeTcpFile>
7730174e:	8b 75 ec             	mov    0xffffffec(%ebp),%esi
77301751:	83 c4 10             	add    $0x10,%esp
77301754:	39 75 e0             	cmp    %esi,0xffffffe0(%ebp)
77301757:	73 2b                	jae    77301784 <_getNumInterfacesInt+0x84>
77301759:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
        if( isInterface( &entitySet[i] ) &&
77301760:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
77301763:	8d 1c f8             	lea    (%eax,%edi,8),%ebx
77301766:	89 d8                	mov    %ebx,%eax
77301768:	e8 f3 fc ff ff       	call   77301460 <_isInterface>
7730176d:	85 c0                	test   %eax,%eax
7730176f:	74 0e                	je     7730177f <_getNumInterfacesInt+0x7f>
77301771:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
77301774:	85 c0                	test   %eax,%eax
77301776:	75 28                	jne    773017a0 <_getNumInterfacesInt+0xa0>
            (!onlyNonLoopback || 
	     (onlyNonLoopback && !isLoopback( tcpFile, &entitySet[i] ))) )
            numInterfaces++;
77301778:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
7730177b:	40                   	inc    %eax
7730177c:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
7730177f:	47                   	inc    %edi
77301780:	39 f7                	cmp    %esi,%edi
77301782:	72 dc                	jb     77301760 <_getNumInterfacesInt+0x60>
    }

    DPRINT("getNumInterfaces: success: %d %d %08x\n", 
           onlyLoopback, numInterfaces, status );

    tdiFreeThingSet( entitySet );
77301784:	83 ec 0c             	sub    $0xc,%esp
77301787:	8b 7d e8             	mov    0xffffffe8(%ebp),%edi
7730178a:	57                   	push   %edi
7730178b:	e8 10 fc ff ff       	call   773013a0 <_tdiFreeThingSet>
    
    return numInterfaces;
77301790:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
}
77301793:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77301796:	89 d0                	mov    %edx,%eax
77301798:	5b                   	pop    %ebx
77301799:	5e                   	pop    %esi
7730179a:	5f                   	pop    %edi
7730179b:	5d                   	pop    %ebp
7730179c:	c3                   	ret    
7730179d:	8d 76 00             	lea    0x0(%esi),%esi
773017a0:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
773017a3:	89 da                	mov    %ebx,%edx
773017a5:	e8 d6 fc ff ff       	call   77301480 <_isLoopback>
773017aa:	85 c0                	test   %eax,%eax
773017ac:	75 05                	jne    773017b3 <_getNumInterfacesInt+0xb3>
773017ae:	8b 75 ec             	mov    0xffffffec(%ebp),%esi
773017b1:	eb c5                	jmp    77301778 <_getNumInterfacesInt+0x78>
773017b3:	8b 75 ec             	mov    0xffffffec(%ebp),%esi
773017b6:	47                   	inc    %edi
773017b7:	39 f7                	cmp    %esi,%edi
773017b9:	eb c7                	jmp    77301782 <_getNumInterfacesInt+0x82>
773017bb:	90                   	nop    
773017bc:	8d 74 26 00          	lea    0x0(%esi),%esi

773017c0 <_getNumInterfaces>:

DWORD getNumInterfaces(void)
{
773017c0:	55                   	push   %ebp
    return getNumInterfacesInt( FALSE );
773017c1:	31 c0                	xor    %eax,%eax
773017c3:	89 e5                	mov    %esp,%ebp
}
773017c5:	5d                   	pop    %ebp
773017c6:	e9 35 ff ff ff       	jmp    77301700 <_getNumInterfacesInt>
773017cb:	90                   	nop    
773017cc:	8d 74 26 00          	lea    0x0(%esi),%esi

773017d0 <_getNumNonLoopbackInterfaces>:

DWORD getNumNonLoopbackInterfaces(void)
{
773017d0:	55                   	push   %ebp
    return getNumInterfacesInt( TRUE );
773017d1:	b8 01 00 00 00       	mov    $0x1,%eax
773017d6:	89 e5                	mov    %esp,%ebp
}
773017d8:	5d                   	pop    %ebp
773017d9:	e9 22 ff ff ff       	jmp    77301700 <_getNumInterfacesInt>
773017de:	89 f6                	mov    %esi,%esi

773017e0 <_getNthInterfaceEntity>:

DWORD getNthInterfaceEntity( HANDLE tcpFile, DWORD index, TDIEntityID *ent ) {
773017e0:	55                   	push   %ebp
773017e1:	89 e5                	mov    %esp,%ebp
773017e3:	57                   	push   %edi
773017e4:	56                   	push   %esi
773017e5:	53                   	push   %ebx
773017e6:	83 ec 10             	sub    $0x10,%esp
    DWORD numEntities = 0;
    DWORD numInterfaces = 0;
    TDIEntityID *entitySet = 0;
    NTSTATUS status = tdiGetEntityIDSet( tcpFile, &entitySet, &numEntities );
773017e9:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
773017ec:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
773017f3:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
773017fa:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
77301801:	50                   	push   %eax
77301802:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
77301805:	50                   	push   %eax
77301806:	8b 4d 08             	mov    0x8(%ebp),%ecx
77301809:	51                   	push   %ecx
7730180a:	e8 11 fc ff ff       	call   77301420 <_tdiGetEntityIDSet>
    int i;

    if( !NT_SUCCESS(status) )
7730180f:	83 c4 10             	add    $0x10,%esp
77301812:	85 c0                	test   %eax,%eax
77301814:	78 4b                	js     77301861 <_getNthInterfaceEntity+0x81>
        return status;

    for( i = 0; i < numEntities; i++ ) {
77301816:	31 f6                	xor    %esi,%esi
77301818:	8b 7d f0             	mov    0xfffffff0(%ebp),%edi
7730181b:	39 fe                	cmp    %edi,%esi
7730181d:	73 25                	jae    77301844 <_getNthInterfaceEntity+0x64>
7730181f:	8b 5d ec             	mov    0xffffffec(%ebp),%ebx
        if( isInterface( &entitySet[i] ) ) {
77301822:	89 d8                	mov    %ebx,%eax
77301824:	e8 37 fc ff ff       	call   77301460 <_isInterface>
77301829:	85 c0                	test   %eax,%eax
7730182b:	74 0f                	je     7730183c <_getNthInterfaceEntity+0x5c>
            if( numInterfaces == index ) break;
7730182d:	8b 45 0c             	mov    0xc(%ebp),%eax
77301830:	39 45 e8             	cmp    %eax,0xffffffe8(%ebp)
77301833:	74 17                	je     7730184c <_getNthInterfaceEntity+0x6c>
            else numInterfaces++;
77301835:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
77301838:	42                   	inc    %edx
77301839:	89 55 e8             	mov    %edx,0xffffffe8(%ebp)
7730183c:	46                   	inc    %esi
7730183d:	83 c3 08             	add    $0x8,%ebx
77301840:	39 fe                	cmp    %edi,%esi
77301842:	72 de                	jb     77301822 <_getNthInterfaceEntity+0x42>
        }
    }

    DPRINT("Index %d is entity #%d - %04x:%08x\n", index, i, 
           entitySet[i].tei_entity, entitySet[i].tei_instance );

    if( numInterfaces == index && i < numEntities ) {
77301844:	8b 4d 0c             	mov    0xc(%ebp),%ecx
77301847:	39 4d e8             	cmp    %ecx,0xffffffe8(%ebp)
7730184a:	75 04                	jne    77301850 <_getNthInterfaceEntity+0x70>
7730184c:	39 fe                	cmp    %edi,%esi
7730184e:	72 19                	jb     77301869 <_getNthInterfaceEntity+0x89>
        memcpy( ent, &entitySet[i], sizeof(*ent) );
        tdiFreeThingSet( entitySet );
        return STATUS_SUCCESS;
    } else {
        tdiFreeThingSet( entitySet );
77301850:	83 ec 0c             	sub    $0xc,%esp
77301853:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
77301856:	50                   	push   %eax
77301857:	e8 44 fb ff ff       	call   773013a0 <_tdiFreeThingSet>
        return STATUS_UNSUCCESSFUL;
7730185c:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
    }
}
77301861:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77301864:	5b                   	pop    %ebx
77301865:	5e                   	pop    %esi
77301866:	5f                   	pop    %edi
77301867:	5d                   	pop    %ebp
77301868:	c3                   	ret    
77301869:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
7730186c:	8b 4d 10             	mov    0x10(%ebp),%ecx
7730186f:	83 ec 0c             	sub    $0xc,%esp
77301872:	8b 14 f0             	mov    (%eax,%esi,8),%edx
77301875:	89 11                	mov    %edx,(%ecx)
77301877:	8b 54 f0 04          	mov    0x4(%eax,%esi,8),%edx
7730187b:	89 51 04             	mov    %edx,0x4(%ecx)
7730187e:	50                   	push   %eax
7730187f:	e8 1c fb ff ff       	call   773013a0 <_tdiFreeThingSet>
77301884:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77301887:	31 c0                	xor    %eax,%eax
77301889:	5b                   	pop    %ebx
7730188a:	5e                   	pop    %esi
7730188b:	5f                   	pop    %edi
7730188c:	5d                   	pop    %ebp
7730188d:	c3                   	ret    
7730188e:	89 f6                	mov    %esi,%esi

77301890 <_getInterfaceInfoByIndex>:

NTSTATUS getInterfaceInfoByIndex( HANDLE tcpFile, DWORD index, IFInfo *info ) {
77301890:	55                   	push   %ebp
77301891:	89 e5                	mov    %esp,%ebp
77301893:	57                   	push   %edi
77301894:	56                   	push   %esi
77301895:	53                   	push   %ebx
77301896:	83 ec 18             	sub    $0x18,%esp
    IFInfo *ifInfo;
    DWORD numInterfaces;
    NTSTATUS status = getInterfaceInfoSet( tcpFile, &ifInfo, &numInterfaces );
77301899:	8d 55 f0             	lea    0xfffffff0(%ebp),%edx
7730189c:	8b 45 08             	mov    0x8(%ebp),%eax
7730189f:	52                   	push   %edx
773018a0:	8d 55 ec             	lea    0xffffffec(%ebp),%edx
773018a3:	e8 78 fc ff ff       	call   77301520 <_getInterfaceInfoSet>
    int i;
    
    if( NT_SUCCESS(status) )
773018a8:	83 c4 10             	add    $0x10,%esp
773018ab:	89 c6                	mov    %eax,%esi
773018ad:	85 c0                	test   %eax,%eax
773018af:	78 45                	js     773018f6 <_getInterfaceInfoByIndex+0x66>
        for( i = 0; i < numInterfaces; i++ ) {
773018b1:	31 db                	xor    %ebx,%ebx
773018b3:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
773018b6:	39 cb                	cmp    %ecx,%ebx
773018b8:	73 24                	jae    773018de <_getInterfaceInfoByIndex+0x4e>
773018ba:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
773018bd:	89 c2                	mov    %eax,%edx
773018bf:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
773018c2:	83 c2 08             	add    $0x8,%edx
773018c5:	31 c0                	xor    %eax,%eax
            if( ifInfo[i].if_info.ent.if_index == index ) {
773018c7:	8b 7d 0c             	mov    0xc(%ebp),%edi
773018ca:	39 3a                	cmp    %edi,(%edx)
773018cc:	74 32                	je     77301900 <_getInterfaceInfoByIndex+0x70>
773018ce:	43                   	inc    %ebx
773018cf:	05 0c 01 00 00       	add    $0x10c,%eax
773018d4:	81 c2 0c 01 00 00    	add    $0x10c,%edx
773018da:	39 cb                	cmp    %ecx,%ebx
773018dc:	72 e9                	jb     773018c7 <_getInterfaceInfoByIndex+0x37>
                memcpy( info, &ifInfo[i], sizeof(*info) );
                break;
            }
        }

    if( NT_SUCCESS(status) )
773018de:	85 f6                	test   %esi,%esi
773018e0:	78 14                	js     773018f6 <_getInterfaceInfoByIndex+0x66>
        return i < numInterfaces ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
773018e2:	31 c0                	xor    %eax,%eax
773018e4:	3b 5d f0             	cmp    0xfffffff0(%ebp),%ebx
773018e7:	72 05                	jb     773018ee <_getInterfaceInfoByIndex+0x5e>
773018e9:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
    else
        return status;
}
773018ee:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773018f1:	5b                   	pop    %ebx
773018f2:	5e                   	pop    %esi
773018f3:	5f                   	pop    %edi
773018f4:	5d                   	pop    %ebp
773018f5:	c3                   	ret    
773018f6:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773018f9:	89 f0                	mov    %esi,%eax
773018fb:	5b                   	pop    %ebx
773018fc:	5e                   	pop    %esi
773018fd:	5f                   	pop    %edi
773018fe:	5d                   	pop    %ebp
773018ff:	c3                   	ret    
77301900:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
77301903:	01 c8                	add    %ecx,%eax
77301905:	52                   	push   %edx
77301906:	68 0c 01 00 00       	push   $0x10c
7730190b:	50                   	push   %eax
7730190c:	8b 7d 10             	mov    0x10(%ebp),%edi
7730190f:	57                   	push   %edi
77301910:	e8 1b 60 00 00       	call   77307930 <_memcpy>
77301915:	83 c4 10             	add    $0x10,%esp
77301918:	eb c4                	jmp    773018de <_getInterfaceInfoByIndex+0x4e>
7730191a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

77301920 <_getInterfaceInfoByName>:
    
NTSTATUS getInterfaceInfoByName( HANDLE tcpFile, char *name, IFInfo *info ) {
77301920:	55                   	push   %ebp
77301921:	89 e5                	mov    %esp,%ebp
77301923:	57                   	push   %edi
77301924:	56                   	push   %esi
77301925:	53                   	push   %ebx
77301926:	83 ec 28             	sub    $0x28,%esp
    IFInfo *ifInfo;
    DWORD numInterfaces;
    int i;    
    NTSTATUS status = getInterfaceInfoSet( tcpFile, &ifInfo, &numInterfaces );
77301929:	8d 55 f0             	lea    0xfffffff0(%ebp),%edx
7730192c:	8b 45 08             	mov    0x8(%ebp),%eax
7730192f:	52                   	push   %edx
77301930:	8d 55 ec             	lea    0xffffffec(%ebp),%edx
77301933:	e8 e8 fb ff ff       	call   77301520 <_getInterfaceInfoSet>
    
    if( NT_SUCCESS(status) )
77301938:	83 c4 10             	add    $0x10,%esp
7730193b:	85 c0                	test   %eax,%eax
7730193d:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
77301940:	78 54                	js     77301996 <_getInterfaceInfoByName+0x76>
        for( i = 0; i < numInterfaces; i++ ) {
77301942:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
77301945:	31 ff                	xor    %edi,%edi
77301947:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
7730194a:	39 c7                	cmp    %eax,%edi
7730194c:	73 2d                	jae    7730197b <_getInterfaceInfoByName+0x5b>
7730194e:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
77301951:	89 c6                	mov    %eax,%esi
77301953:	8d 58 64             	lea    0x64(%eax),%ebx
            if( !strcmp(ifInfo[i].if_info.ent.if_descr, name) ) {
77301956:	50                   	push   %eax
77301957:	50                   	push   %eax
77301958:	8b 45 0c             	mov    0xc(%ebp),%eax
7730195b:	50                   	push   %eax
7730195c:	53                   	push   %ebx
7730195d:	e8 0e 60 00 00       	call   77307970 <_strcmp>
77301962:	83 c4 10             	add    $0x10,%esp
77301965:	85 c0                	test   %eax,%eax
77301967:	74 38                	je     773019a1 <_getInterfaceInfoByName+0x81>
77301969:	47                   	inc    %edi
7730196a:	81 c6 0c 01 00 00    	add    $0x10c,%esi
77301970:	81 c3 0c 01 00 00    	add    $0x10c,%ebx
77301976:	3b 7d e4             	cmp    0xffffffe4(%ebp),%edi
77301979:	72 db                	jb     77301956 <_getInterfaceInfoByName+0x36>
                memcpy( info, &ifInfo[i], sizeof(*info) );
                break;
            }
        }
    
    if( NT_SUCCESS(status) )
7730197b:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
7730197e:	85 c0                	test   %eax,%eax
77301980:	78 14                	js     77301996 <_getInterfaceInfoByName+0x76>
        return i < numInterfaces ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
77301982:	31 c0                	xor    %eax,%eax
77301984:	3b 7d f0             	cmp    0xfffffff0(%ebp),%edi
77301987:	72 05                	jb     7730198e <_getInterfaceInfoByName+0x6e>
77301989:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
    else
        return status;
}
7730198e:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77301991:	5b                   	pop    %ebx
77301992:	5e                   	pop    %esi
77301993:	5f                   	pop    %edi
77301994:	5d                   	pop    %ebp
77301995:	c3                   	ret    
77301996:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
77301999:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
7730199c:	5b                   	pop    %ebx
7730199d:	5e                   	pop    %esi
7730199e:	5f                   	pop    %edi
7730199f:	5d                   	pop    %ebp
773019a0:	c3                   	ret    
773019a1:	50                   	push   %eax
773019a2:	68 0c 01 00 00       	push   $0x10c
773019a7:	56                   	push   %esi
773019a8:	8b 5d 10             	mov    0x10(%ebp),%ebx
773019ab:	53                   	push   %ebx
773019ac:	e8 7f 5f 00 00       	call   77307930 <_memcpy>
773019b1:	83 c4 10             	add    $0x10,%esp
773019b4:	eb c5                	jmp    7730197b <_getInterfaceInfoByName+0x5b>
773019b6:	8d 76 00             	lea    0x0(%esi),%esi
773019b9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

773019c0 <_getInterfaceNameByIndex>:
    
/* Note that the result of this operation must be freed later */

const char *getInterfaceNameByIndex(DWORD index)
{
773019c0:	55                   	push   %ebp
773019c1:	89 e5                	mov    %esp,%ebp
773019c3:	56                   	push   %esi
773019c4:	53                   	push   %ebx
    IFInfo ifInfo;
    HANDLE tcpFile;
    char *interfaceName = 0, *adapter_name = 0;
773019c5:	31 f6                	xor    %esi,%esi
773019c7:	81 ec 2c 01 00 00    	sub    $0x12c,%esp
    NTSTATUS status = openTcpFile( &tcpFile );
773019cd:	8d 85 e4 fe ff ff    	lea    0xfffffee4(%ebp),%eax
773019d3:	50                   	push   %eax
773019d4:	e8 17 f8 ff ff       	call   773011f0 <_openTcpFile>

    if( NT_SUCCESS(status) ) {
773019d9:	83 c4 10             	add    $0x10,%esp
773019dc:	85 c0                	test   %eax,%eax
773019de:	78 5d                	js     77301a3d <_getInterfaceNameByIndex+0x7d>
        status = getInterfaceInfoByIndex( tcpFile, index, &ifInfo );
773019e0:	50                   	push   %eax
773019e1:	8d 85 e8 fe ff ff    	lea    0xfffffee8(%ebp),%eax
773019e7:	8b 9d e4 fe ff ff    	mov    0xfffffee4(%ebp),%ebx
773019ed:	50                   	push   %eax
773019ee:	8b 45 08             	mov    0x8(%ebp),%eax
773019f1:	50                   	push   %eax
773019f2:	53                   	push   %ebx
773019f3:	e8 98 fe ff ff       	call   77301890 <_getInterfaceInfoByIndex>
        
        if( NT_SUCCESS(status) ) {
773019f8:	83 c4 10             	add    $0x10,%esp
773019fb:	85 c0                	test   %eax,%eax
773019fd:	78 3e                	js     77301a3d <_getInterfaceNameByIndex+0x7d>
            adapter_name = ifInfo.if_info.ent.if_descr;
            
            interfaceName = HeapAlloc( GetProcessHeap(), 0, 
773019ff:	83 ec 0c             	sub    $0xc,%esp
77301a02:	8d 9d 4c ff ff ff    	lea    0xffffff4c(%ebp),%ebx
77301a08:	53                   	push   %ebx
77301a09:	e8 52 5f 00 00       	call   77307960 <_strlen>
77301a0e:	83 c4 0c             	add    $0xc,%esp
77301a11:	40                   	inc    %eax
77301a12:	50                   	push   %eax
77301a13:	6a 00                	push   $0x0
77301a15:	51                   	push   %ecx
77301a16:	e8 15 3a 00 00       	call   77305430 <_GetProcessHeap@0>
77301a1b:	89 04 24             	mov    %eax,(%esp)
77301a1e:	e8 1d 3a 00 00       	call   77305440 <_HeapAlloc@12>
77301a23:	89 c6                	mov    %eax,%esi
                                       strlen(adapter_name) + 1 );
            strcpy( interfaceName, adapter_name );
77301a25:	52                   	push   %edx
77301a26:	53                   	push   %ebx
77301a27:	50                   	push   %eax
77301a28:	e8 23 5f 00 00       	call   77307950 <_strcpy>
            
            closeTcpFile( tcpFile );
77301a2d:	58                   	pop    %eax
77301a2e:	8b 85 e4 fe ff ff    	mov    0xfffffee4(%ebp),%eax
77301a34:	50                   	push   %eax
77301a35:	e8 26 f8 ff ff       	call   77301260 <_closeTcpFile>
77301a3a:	83 c4 10             	add    $0x10,%esp
        }
    }

    return interfaceName;
}
77301a3d:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
77301a40:	89 f0                	mov    %esi,%eax
77301a42:	5b                   	pop    %ebx
77301a43:	5e                   	pop    %esi
77301a44:	5d                   	pop    %ebp
77301a45:	c3                   	ret    
77301a46:	8d 76 00             	lea    0x0(%esi),%esi
77301a49:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77301a50 <_consumeInterfaceName>:

void consumeInterfaceName(const char *name) {
77301a50:	55                   	push   %ebp
77301a51:	89 e5                	mov    %esp,%ebp
77301a53:	83 ec 0c             	sub    $0xc,%esp
    HeapFree( GetProcessHeap(), 0, (char *)name );
77301a56:	8b 45 08             	mov    0x8(%ebp),%eax
77301a59:	50                   	push   %eax
77301a5a:	6a 00                	push   $0x0
77301a5c:	50                   	push   %eax
77301a5d:	e8 ce 39 00 00       	call   77305430 <_GetProcessHeap@0>
77301a62:	89 04 24             	mov    %eax,(%esp)
77301a65:	e8 e6 39 00 00       	call   77305450 <_HeapFree@12>
77301a6a:	c9                   	leave  
77301a6b:	c3                   	ret    
77301a6c:	8d 74 26 00          	lea    0x0(%esi),%esi

77301a70 <_getInterfaceIndexByName>:
}

DWORD getInterfaceIndexByName(const char *name, PDWORD index)
{
77301a70:	55                   	push   %ebp
77301a71:	89 e5                	mov    %esp,%ebp
77301a73:	53                   	push   %ebx
77301a74:	81 ec 30 01 00 00    	sub    $0x130,%esp
    IFInfo ifInfo;
    HANDLE tcpFile;
    NTSTATUS status = openTcpFile( &tcpFile );
77301a7a:	8d 85 e4 fe ff ff    	lea    0xfffffee4(%ebp),%eax
77301a80:	50                   	push   %eax
77301a81:	e8 6a f7 ff ff       	call   773011f0 <_openTcpFile>

    if( NT_SUCCESS(status) ) {
77301a86:	83 c4 10             	add    $0x10,%esp
77301a89:	89 c3                	mov    %eax,%ebx
77301a8b:	85 c0                	test   %eax,%eax
77301a8d:	78 3e                	js     77301acd <_getInterfaceIndexByName+0x5d>
        status = getInterfaceInfoByName( tcpFile, (char *)name, &ifInfo );
77301a8f:	8d 85 e8 fe ff ff    	lea    0xfffffee8(%ebp),%eax
77301a95:	8b 55 08             	mov    0x8(%ebp),%edx
77301a98:	51                   	push   %ecx
77301a99:	50                   	push   %eax
77301a9a:	8b 85 e4 fe ff ff    	mov    0xfffffee4(%ebp),%eax
77301aa0:	52                   	push   %edx
77301aa1:	50                   	push   %eax
77301aa2:	e8 79 fe ff ff       	call   77301920 <_getInterfaceInfoByName>
        
        if( NT_SUCCESS(status) ) {
77301aa7:	83 c4 10             	add    $0x10,%esp
77301aaa:	89 c3                	mov    %eax,%ebx
77301aac:	85 c0                	test   %eax,%eax
77301aae:	78 1d                	js     77301acd <_getInterfaceIndexByName+0x5d>
            *index = ifInfo.if_info.ent.if_index;
77301ab0:	8b 45 0c             	mov    0xc(%ebp),%eax
            closeTcpFile( tcpFile );
77301ab3:	83 ec 0c             	sub    $0xc,%esp
77301ab6:	8b 95 f0 fe ff ff    	mov    0xfffffef0(%ebp),%edx
77301abc:	89 10                	mov    %edx,(%eax)
77301abe:	8b 85 e4 fe ff ff    	mov    0xfffffee4(%ebp),%eax
77301ac4:	50                   	push   %eax
77301ac5:	e8 96 f7 ff ff       	call   77301260 <_closeTcpFile>
77301aca:	83 c4 10             	add    $0x10,%esp
        }
    }

    return status;
}
77301acd:	89 d8                	mov    %ebx,%eax
77301acf:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
77301ad2:	c9                   	leave  
77301ad3:	c3                   	ret    
77301ad4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77301ada:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

77301ae0 <_getInterfaceIndexTableInt>:

InterfaceIndexTable *getInterfaceIndexTableInt( BOOL nonLoopbackOnly ) {
77301ae0:	55                   	push   %ebp
77301ae1:	89 e5                	mov    %esp,%ebp
77301ae3:	57                   	push   %edi
77301ae4:	56                   	push   %esi
77301ae5:	53                   	push   %ebx
77301ae6:	83 ec 28             	sub    $0x28,%esp
  DWORD numInterfaces, curInterface = 0;
  int i;
  IFInfo *ifInfo;
  InterfaceIndexTable *ret = 0;
  HANDLE tcpFile;
  NTSTATUS status = openTcpFile( &tcpFile );
77301ae9:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
77301aec:	c7 45 e4 00 00 00 00 	movl   $0x0,0xffffffe4(%ebp)
77301af3:	c7 45 e0 00 00 00 00 	movl   $0x0,0xffffffe0(%ebp)
77301afa:	50                   	push   %eax
77301afb:	e8 f0 f6 ff ff       	call   773011f0 <_openTcpFile>

  if( NT_SUCCESS(status) ) {
77301b00:	83 c4 10             	add    $0x10,%esp
77301b03:	85 c0                	test   %eax,%eax
77301b05:	0f 88 ce 00 00 00    	js     77301bd9 <_getInterfaceIndexTableInt+0xf9>
      status = getInterfaceInfoSet( tcpFile, &ifInfo, &numInterfaces );
77301b0b:	83 ec 0c             	sub    $0xc,%esp
77301b0e:	8d 55 ec             	lea    0xffffffec(%ebp),%edx
77301b11:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
77301b14:	52                   	push   %edx
77301b15:	8d 55 e8             	lea    0xffffffe8(%ebp),%edx
77301b18:	e8 03 fa ff ff       	call   77301520 <_getInterfaceInfoSet>

      DPRINT("InterfaceInfoSet: %08x, %04x:%08x\n", 
	     status, 
	     ifInfo->entity_id.tei_entity,
	     ifInfo->entity_id.tei_instance);

      if( NT_SUCCESS(status) ) {
77301b1d:	83 c4 10             	add    $0x10,%esp
77301b20:	85 c0                	test   %eax,%eax
77301b22:	0f 88 a2 00 00 00    	js     77301bca <_getInterfaceIndexTableInt+0xea>
          ret = (InterfaceIndexTable *)
77301b28:	50                   	push   %eax
77301b29:	50                   	push   %eax
77301b2a:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
77301b2d:	8d 04 85 08 00 00 00 	lea    0x8(,%eax,4),%eax
77301b34:	50                   	push   %eax
77301b35:	6a 01                	push   $0x1
77301b37:	e8 14 64 00 00       	call   77307f50 <_calloc>
              calloc(1,
                     sizeof(InterfaceIndexTable) + 
                     (numInterfaces - 1) * sizeof(DWORD));
          
          if (ret) {
77301b3c:	83 c4 10             	add    $0x10,%esp
77301b3f:	85 c0                	test   %eax,%eax
77301b41:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
77301b44:	74 75                	je     77301bbb <_getInterfaceIndexTableInt+0xdb>
              ret->numAllocated = numInterfaces;
77301b46:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
77301b49:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
	      DPRINT("NumInterfaces = %d\n", numInterfaces);
          
              for( i = 0; i < numInterfaces; i++ ) {
77301b4c:	31 f6                	xor    %esi,%esi
77301b4e:	39 45 e4             	cmp    %eax,0xffffffe4(%ebp)
77301b51:	89 42 04             	mov    %eax,0x4(%edx)
77301b54:	73 5d                	jae    77301bb3 <_getInterfaceIndexTableInt+0xd3>
77301b56:	31 db                	xor    %ebx,%ebx
77301b58:	31 ff                	xor    %edi,%edi
77301b5a:	eb 2b                	jmp    77301b87 <_getInterfaceIndexTableInt+0xa7>
77301b5c:	8d 74 26 00          	lea    0x0(%esi),%esi
		  DPRINT("Examining interface %d\n", i);
                  if( !nonLoopbackOnly || 
                      !isLoopback( tcpFile, &ifInfo[i].entity_id ) ) {
		      DPRINT("Interface %d matches (%d)\n", i, curInterface);
                      ret->indexes[curInterface++] = 
77301b60:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
77301b63:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
77301b66:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
77301b69:	46                   	inc    %esi
77301b6a:	8b 44 03 08          	mov    0x8(%ebx,%eax,1),%eax
77301b6e:	81 c7 0c 01 00 00    	add    $0x10c,%edi
77301b74:	89 44 8a 08          	mov    %eax,0x8(%edx,%ecx,4)
77301b78:	41                   	inc    %ecx
77301b79:	81 c3 0c 01 00 00    	add    $0x10c,%ebx
77301b7f:	89 4d e4             	mov    %ecx,0xffffffe4(%ebp)
77301b82:	3b 75 ec             	cmp    0xffffffec(%ebp),%esi
77301b85:	73 2c                	jae    77301bb3 <_getInterfaceIndexTableInt+0xd3>
77301b87:	8b 45 08             	mov    0x8(%ebp),%eax
77301b8a:	85 c0                	test   %eax,%eax
77301b8c:	74 d2                	je     77301b60 <_getInterfaceIndexTableInt+0x80>
77301b8e:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
77301b91:	89 fa                	mov    %edi,%edx
77301b93:	01 c2                	add    %eax,%edx
77301b95:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
77301b98:	e8 e3 f8 ff ff       	call   77301480 <_isLoopback>
77301b9d:	85 c0                	test   %eax,%eax
77301b9f:	74 bf                	je     77301b60 <_getInterfaceIndexTableInt+0x80>
77301ba1:	46                   	inc    %esi
77301ba2:	81 c7 0c 01 00 00    	add    $0x10c,%edi
77301ba8:	81 c3 0c 01 00 00    	add    $0x10c,%ebx
77301bae:	3b 75 ec             	cmp    0xffffffec(%ebp),%esi
77301bb1:	72 d4                	jb     77301b87 <_getInterfaceIndexTableInt+0xa7>
                          ifInfo[i].if_info.ent.if_index;
                  }
              } 

              ret->numIndexes = curInterface;
77301bb3:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
77301bb6:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
77301bb9:	89 08                	mov    %ecx,(%eax)
          }
          
          tdiFreeThingSet( ifInfo );
77301bbb:	83 ec 0c             	sub    $0xc,%esp
77301bbe:	8b 75 e8             	mov    0xffffffe8(%ebp),%esi
77301bc1:	56                   	push   %esi
77301bc2:	e8 d9 f7 ff ff       	call   773013a0 <_tdiFreeThingSet>
77301bc7:	83 c4 10             	add    $0x10,%esp
      }
      closeTcpFile( tcpFile );
77301bca:	83 ec 0c             	sub    $0xc,%esp
77301bcd:	8b 5d f0             	mov    0xfffffff0(%ebp),%ebx
77301bd0:	53                   	push   %ebx
77301bd1:	e8 8a f6 ff ff       	call   77301260 <_closeTcpFile>
77301bd6:	83 c4 10             	add    $0x10,%esp
  }
              
  return ret;
}
77301bd9:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
77301bdc:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77301bdf:	5b                   	pop    %ebx
77301be0:	5e                   	pop    %esi
77301be1:	5f                   	pop    %edi
77301be2:	5d                   	pop    %ebp
77301be3:	c3                   	ret    
77301be4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77301bea:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

77301bf0 <_getInterfaceIndexTable>:

InterfaceIndexTable *getInterfaceIndexTable(void) {
77301bf0:	55                   	push   %ebp
77301bf1:	89 e5                	mov    %esp,%ebp
77301bf3:	83 ec 14             	sub    $0x14,%esp
    return getInterfaceIndexTableInt( FALSE );
77301bf6:	6a 00                	push   $0x0
77301bf8:	e8 e3 fe ff ff       	call   77301ae0 <_getInterfaceIndexTableInt>
}
77301bfd:	c9                   	leave  
77301bfe:	c3                   	ret    
77301bff:	90                   	nop    

77301c00 <_getNonLoopbackInterfaceIndexTable>:

InterfaceIndexTable *getNonLoopbackInterfaceIndexTable(void) {
77301c00:	55                   	push   %ebp
77301c01:	89 e5                	mov    %esp,%ebp
77301c03:	83 ec 14             	sub    $0x14,%esp
    return getInterfaceIndexTableInt( TRUE );
77301c06:	6a 01                	push   $0x1
77301c08:	e8 d3 fe ff ff       	call   77301ae0 <_getInterfaceIndexTableInt>
}
77301c0d:	c9                   	leave  
77301c0e:	c3                   	ret    
77301c0f:	90                   	nop    

77301c10 <_getInterfaceIPAddrByName>:

DWORD getInterfaceIPAddrByName(const char *name)
{
77301c10:	55                   	push   %ebp
    return INADDR_ANY;
}
77301c11:	31 c0                	xor    %eax,%eax
77301c13:	89 e5                	mov    %esp,%ebp
77301c15:	5d                   	pop    %ebp
77301c16:	c3                   	ret    
77301c17:	89 f6                	mov    %esi,%esi
77301c19:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77301c20 <_getIPAddrEntryForIf>:

NTSTATUS getIPAddrEntryForIf(HANDLE tcpFile, 
                             char *name,
                             DWORD index,
                             IFInfo *ifInfo) {
77301c20:	55                   	push   %ebp
77301c21:	89 e5                	mov    %esp,%ebp
77301c23:	50                   	push   %eax
77301c24:	50                   	push   %eax
77301c25:	8b 45 0c             	mov    0xc(%ebp),%eax
77301c28:	8b 4d 08             	mov    0x8(%ebp),%ecx
77301c2b:	8b 55 14             	mov    0x14(%ebp),%edx
    NTSTATUS status = 
77301c2e:	85 c0                	test   %eax,%eax
77301c30:	74 10                	je     77301c42 <_getIPAddrEntryForIf+0x22>
77301c32:	83 ec 04             	sub    $0x4,%esp
77301c35:	52                   	push   %edx
77301c36:	50                   	push   %eax
77301c37:	51                   	push   %ecx
77301c38:	e8 e3 fc ff ff       	call   77301920 <_getInterfaceInfoByName>
77301c3d:	83 c4 10             	add    $0x10,%esp
        name ? 
        getInterfaceInfoByName( tcpFile, name, ifInfo ) :
        getInterfaceInfoByIndex( tcpFile, index, ifInfo );
    return status;
}
77301c40:	c9                   	leave  
77301c41:	c3                   	ret    
77301c42:	50                   	push   %eax
77301c43:	52                   	push   %edx
77301c44:	8b 45 10             	mov    0x10(%ebp),%eax
77301c47:	50                   	push   %eax
77301c48:	51                   	push   %ecx
77301c49:	e8 42 fc ff ff       	call   77301890 <_getInterfaceInfoByIndex>
77301c4e:	83 c4 10             	add    $0x10,%esp
77301c51:	c9                   	leave  
77301c52:	c3                   	ret    
77301c53:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77301c59:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77301c60 <_getAddrByIndexOrName>:

DWORD getAddrByIndexOrName( char *name, DWORD index, IPHLPAddrType addrType ) {
77301c60:	55                   	push   %ebp
77301c61:	89 e5                	mov    %esp,%ebp
77301c63:	57                   	push   %edi
77301c64:	56                   	push   %esi
77301c65:	53                   	push   %ebx
77301c66:	81 ec 38 01 00 00    	sub    $0x138,%esp
    IFInfo ifInfo;
    HANDLE tcpFile = INVALID_HANDLE_VALUE;
    NTSTATUS status = STATUS_SUCCESS;
    DWORD addrOut = INADDR_ANY;

    status = openTcpFile( &tcpFile );
77301c6c:	8d b5 d4 fe ff ff    	lea    0xfffffed4(%ebp),%esi
77301c72:	8b 7d 10             	mov    0x10(%ebp),%edi
77301c75:	c7 85 d4 fe ff ff ff 	movl   $0xffffffff,0xfffffed4(%ebp)
77301c7c:	ff ff ff 
77301c7f:	56                   	push   %esi
77301c80:	e8 6b f5 ff ff       	call   773011f0 <_openTcpFile>
77301c85:	31 db                	xor    %ebx,%ebx

    if( NT_SUCCESS(status) ) {
77301c87:	83 c4 10             	add    $0x10,%esp
77301c8a:	85 c0                	test   %eax,%eax
77301c8c:	78 40                	js     77301cce <_getAddrByIndexOrName+0x6e>
        status = getIPAddrEntryForIf( tcpFile, name, index, &ifInfo );
77301c8e:	8d 85 d8 fe ff ff    	lea    0xfffffed8(%ebp),%eax
77301c94:	8b 4d 08             	mov    0x8(%ebp),%ecx
77301c97:	50                   	push   %eax
77301c98:	8b 95 d4 fe ff ff    	mov    0xfffffed4(%ebp),%edx
77301c9e:	8b 45 0c             	mov    0xc(%ebp),%eax
77301ca1:	50                   	push   %eax
77301ca2:	51                   	push   %ecx
77301ca3:	52                   	push   %edx
77301ca4:	e8 77 ff ff ff       	call   77301c20 <_getIPAddrEntryForIf>
        if( NT_SUCCESS(status) ) {
77301ca9:	83 c4 10             	add    $0x10,%esp
77301cac:	85 c0                	test   %eax,%eax
77301cae:	78 12                	js     77301cc2 <_getAddrByIndexOrName+0x62>
            switch( addrType ) {
77301cb0:	83 ff 04             	cmp    $0x4,%edi
77301cb3:	77 0d                	ja     77301cc2 <_getAddrByIndexOrName+0x62>
77301cb5:	ff 24 bd 84 a0 30 77 	jmp    *0x7730a084(,%edi,4)
            case IPAAddr:  addrOut = ifInfo.ip_addr.iae_addr; break;
            case IPABcast: addrOut = ifInfo.ip_addr.iae_bcastaddr; break;
            case IPAMask:  addrOut = ifInfo.ip_addr.iae_mask; break;
            case IFMtu:    addrOut = ifInfo.if_info.ent.if_mtu; break;
            case IFStatus: addrOut = ifInfo.if_info.ent.if_operstatus; break;
77301cbc:	8b 9d 00 ff ff ff    	mov    0xffffff00(%ebp),%ebx
            }
        }
        closeTcpFile( &tcpFile );
77301cc2:	83 ec 0c             	sub    $0xc,%esp
77301cc5:	56                   	push   %esi
77301cc6:	e8 95 f5 ff ff       	call   77301260 <_closeTcpFile>
77301ccb:	83 c4 10             	add    $0x10,%esp
    }

    return addrOut;
}                           
77301cce:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77301cd1:	89 d8                	mov    %ebx,%eax
77301cd3:	5b                   	pop    %ebx
77301cd4:	5e                   	pop    %esi
77301cd5:	5f                   	pop    %edi
77301cd6:	5d                   	pop    %ebp
77301cd7:	c3                   	ret    
77301cd8:	8b 5d c8             	mov    0xffffffc8(%ebp),%ebx
77301cdb:	eb e5                	jmp    77301cc2 <_getAddrByIndexOrName+0x62>
77301cdd:	8b 5d d4             	mov    0xffffffd4(%ebp),%ebx
77301ce0:	eb e0                	jmp    77301cc2 <_getAddrByIndexOrName+0x62>
77301ce2:	8b 5d d0             	mov    0xffffffd0(%ebp),%ebx
77301ce5:	eb db                	jmp    77301cc2 <_getAddrByIndexOrName+0x62>
77301ce7:	8b 9d e8 fe ff ff    	mov    0xfffffee8(%ebp),%ebx
77301ced:	eb d3                	jmp    77301cc2 <_getAddrByIndexOrName+0x62>
77301cef:	90                   	nop    

77301cf0 <_getInterfaceIPAddrByIndex>:

DWORD getInterfaceIPAddrByIndex(DWORD index) {
77301cf0:	55                   	push   %ebp
77301cf1:	89 e5                	mov    %esp,%ebp
77301cf3:	83 ec 0c             	sub    $0xc,%esp
    return getAddrByIndexOrName( 0, index, IPAAddr );
77301cf6:	8b 45 08             	mov    0x8(%ebp),%eax
77301cf9:	6a 00                	push   $0x0
77301cfb:	50                   	push   %eax
77301cfc:	6a 00                	push   $0x0
77301cfe:	e8 5d ff ff ff       	call   77301c60 <_getAddrByIndexOrName>
}
77301d03:	c9                   	leave  
77301d04:	c3                   	ret    
77301d05:	8d 74 26 00          	lea    0x0(%esi),%esi
77301d09:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77301d10 <_getInterfaceBCastAddrByName>:

DWORD getInterfaceBCastAddrByName(const char *name) {
77301d10:	55                   	push   %ebp
77301d11:	89 e5                	mov    %esp,%ebp
77301d13:	83 ec 0c             	sub    $0xc,%esp
    return getAddrByIndexOrName( (char *)name, 0, IPABcast );
77301d16:	8b 45 08             	mov    0x8(%ebp),%eax
77301d19:	6a 01                	push   $0x1
77301d1b:	6a 00                	push   $0x0
77301d1d:	50                   	push   %eax
77301d1e:	e8 3d ff ff ff       	call   77301c60 <_getAddrByIndexOrName>
}
77301d23:	c9                   	leave  
77301d24:	c3                   	ret    
77301d25:	8d 74 26 00          	lea    0x0(%esi),%esi
77301d29:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77301d30 <_getInterfaceBCastAddrByIndex>:

DWORD getInterfaceBCastAddrByIndex(DWORD index) {
77301d30:	55                   	push   %ebp
77301d31:	89 e5                	mov    %esp,%ebp
77301d33:	83 ec 0c             	sub    $0xc,%esp
    return getAddrByIndexOrName( 0, index, IPABcast );
77301d36:	8b 45 08             	mov    0x8(%ebp),%eax
77301d39:	6a 01                	push   $0x1
77301d3b:	50                   	push   %eax
77301d3c:	6a 00                	push   $0x0
77301d3e:	e8 1d ff ff ff       	call   77301c60 <_getAddrByIndexOrName>
}
77301d43:	c9                   	leave  
77301d44:	c3                   	ret    
77301d45:	8d 74 26 00          	lea    0x0(%esi),%esi
77301d49:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77301d50 <_getInterfaceMaskByName>:

DWORD getInterfaceMaskByName(const char *name) {
77301d50:	55                   	push   %ebp
77301d51:	89 e5                	mov    %esp,%ebp
77301d53:	83 ec 0c             	sub    $0xc,%esp
    return getAddrByIndexOrName( (char *)name, 0, IPAMask );
77301d56:	8b 45 08             	mov    0x8(%ebp),%eax
77301d59:	6a 02                	push   $0x2
77301d5b:	6a 00                	push   $0x0
77301d5d:	50                   	push   %eax
77301d5e:	e8 fd fe ff ff       	call   77301c60 <_getAddrByIndexOrName>
}
77301d63:	c9                   	leave  
77301d64:	c3                   	ret    
77301d65:	8d 74 26 00          	lea    0x0(%esi),%esi
77301d69:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77301d70 <_getInterfaceMaskByIndex>:

DWORD getInterfaceMaskByIndex(DWORD index) {
77301d70:	55                   	push   %ebp
77301d71:	89 e5                	mov    %esp,%ebp
77301d73:	83 ec 0c             	sub    $0xc,%esp
    return getAddrByIndexOrName( 0, index, IPAMask );
77301d76:	8b 45 08             	mov    0x8(%ebp),%eax
77301d79:	6a 02                	push   $0x2
77301d7b:	50                   	push   %eax
77301d7c:	6a 00                	push   $0x0
77301d7e:	e8 dd fe ff ff       	call   77301c60 <_getAddrByIndexOrName>
}
77301d83:	c9                   	leave  
77301d84:	c3                   	ret    
77301d85:	8d 74 26 00          	lea    0x0(%esi),%esi
77301d89:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77301d90 <_getInterfacePhysicalFromInfo>:

void getInterfacePhysicalFromInfo( IFInfo *info, 
                                   PDWORD len, PBYTE addr, PDWORD type ) {
77301d90:	55                   	push   %ebp
77301d91:	89 e5                	mov    %esp,%ebp
77301d93:	53                   	push   %ebx
77301d94:	51                   	push   %ecx
77301d95:	51                   	push   %ecx
77301d96:	8b 5d 08             	mov    0x8(%ebp),%ebx
    *len = info->if_info.ent.if_physaddrlen;
77301d99:	8b 45 0c             	mov    0xc(%ebp),%eax
77301d9c:	8b 53 18             	mov    0x18(%ebx),%edx
77301d9f:	89 10                	mov    %edx,(%eax)
    memcpy( addr, info->if_info.ent.if_physaddr, *len );
77301da1:	52                   	push   %edx
77301da2:	8d 43 1c             	lea    0x1c(%ebx),%eax
77301da5:	8b 55 10             	mov    0x10(%ebp),%edx
77301da8:	50                   	push   %eax
77301da9:	52                   	push   %edx
77301daa:	e8 81 5b 00 00       	call   77307930 <_memcpy>
    *type = info->if_info.ent.if_type;
77301daf:	8b 45 14             	mov    0x14(%ebp),%eax
77301db2:	8b 53 0c             	mov    0xc(%ebx),%edx
77301db5:	89 10                	mov    %edx,(%eax)
77301db7:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
77301dba:	c9                   	leave  
77301dbb:	c3                   	ret    
77301dbc:	8d 74 26 00          	lea    0x0(%esi),%esi

77301dc0 <_getInterfacePhysicalByName>:
}

DWORD getInterfacePhysicalByName(const char *name, PDWORD len, PBYTE addr,
                                 PDWORD type)
{
77301dc0:	55                   	push   %ebp
77301dc1:	89 e5                	mov    %esp,%ebp
77301dc3:	56                   	push   %esi
77301dc4:	53                   	push   %ebx
77301dc5:	81 ec 2c 01 00 00    	sub    $0x12c,%esp
    HANDLE tcpFile;
    IFInfo info;
    NTSTATUS status = openTcpFile( &tcpFile );
77301dcb:	8d 85 e4 fe ff ff    	lea    0xfffffee4(%ebp),%eax
77301dd1:	50                   	push   %eax
77301dd2:	e8 19 f4 ff ff       	call   773011f0 <_openTcpFile>

    if( NT_SUCCESS(status) ) {
77301dd7:	83 c4 10             	add    $0x10,%esp
77301dda:	89 c3                	mov    %eax,%ebx
77301ddc:	85 c0                	test   %eax,%eax
77301dde:	78 48                	js     77301e28 <_getInterfacePhysicalByName+0x68>
        status = getInterfaceInfoByName( tcpFile, (char *)name, &info );
77301de0:	8d b5 e8 fe ff ff    	lea    0xfffffee8(%ebp),%esi
77301de6:	50                   	push   %eax
77301de7:	8b 45 08             	mov    0x8(%ebp),%eax
77301dea:	56                   	push   %esi
77301deb:	50                   	push   %eax
77301dec:	8b 85 e4 fe ff ff    	mov    0xfffffee4(%ebp),%eax
77301df2:	50                   	push   %eax
77301df3:	e8 28 fb ff ff       	call   77301920 <_getInterfaceInfoByName>
        if( NT_SUCCESS(status) ) 
77301df8:	83 c4 10             	add    $0x10,%esp
77301dfb:	89 c3                	mov    %eax,%ebx
77301dfd:	85 c0                	test   %eax,%eax
77301dff:	78 15                	js     77301e16 <_getInterfacePhysicalByName+0x56>
            getInterfacePhysicalFromInfo( &info, len, addr, type );
77301e01:	8b 45 14             	mov    0x14(%ebp),%eax
77301e04:	50                   	push   %eax
77301e05:	8b 45 10             	mov    0x10(%ebp),%eax
77301e08:	50                   	push   %eax
77301e09:	8b 45 0c             	mov    0xc(%ebp),%eax
77301e0c:	50                   	push   %eax
77301e0d:	56                   	push   %esi
77301e0e:	e8 7d ff ff ff       	call   77301d90 <_getInterfacePhysicalFromInfo>
77301e13:	83 c4 10             	add    $0x10,%esp
        closeTcpFile( tcpFile );
77301e16:	83 ec 0c             	sub    $0xc,%esp
77301e19:	8b b5 e4 fe ff ff    	mov    0xfffffee4(%ebp),%esi
77301e1f:	56                   	push   %esi
77301e20:	e8 3b f4 ff ff       	call   77301260 <_closeTcpFile>
77301e25:	83 c4 10             	add    $0x10,%esp
    }

    return status;
}
77301e28:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
77301e2b:	89 d8                	mov    %ebx,%eax
77301e2d:	5b                   	pop    %ebx
77301e2e:	5e                   	pop    %esi
77301e2f:	5d                   	pop    %ebp
77301e30:	c3                   	ret    
77301e31:	eb 0d                	jmp    77301e40 <_getInterfacePhysicalByIndex>
77301e33:	90                   	nop    
77301e34:	90                   	nop    
77301e35:	90                   	nop    
77301e36:	90                   	nop    
77301e37:	90                   	nop    
77301e38:	90                   	nop    
77301e39:	90                   	nop    
77301e3a:	90                   	nop    
77301e3b:	90                   	nop    
77301e3c:	90                   	nop    
77301e3d:	90                   	nop    
77301e3e:	90                   	nop    
77301e3f:	90                   	nop    

77301e40 <_getInterfacePhysicalByIndex>:

DWORD getInterfacePhysicalByIndex(DWORD index, PDWORD len, PBYTE addr,
 PDWORD type)
{
77301e40:	55                   	push   %ebp
77301e41:	89 e5                	mov    %esp,%ebp
77301e43:	56                   	push   %esi
77301e44:	53                   	push   %ebx
77301e45:	81 ec 2c 01 00 00    	sub    $0x12c,%esp
    HANDLE tcpFile;
    IFInfo info;
    NTSTATUS status = openTcpFile( &tcpFile );
77301e4b:	8d 85 e4 fe ff ff    	lea    0xfffffee4(%ebp),%eax
77301e51:	50                   	push   %eax
77301e52:	e8 99 f3 ff ff       	call   773011f0 <_openTcpFile>

    if( NT_SUCCESS(status) ) {
77301e57:	83 c4 10             	add    $0x10,%esp
77301e5a:	89 c3                	mov    %eax,%ebx
77301e5c:	85 c0                	test   %eax,%eax
77301e5e:	78 48                	js     77301ea8 <_getInterfacePhysicalByIndex+0x68>
        status = getInterfaceInfoByIndex( tcpFile, index, &info );
77301e60:	8d b5 e8 fe ff ff    	lea    0xfffffee8(%ebp),%esi
77301e66:	50                   	push   %eax
77301e67:	8b 45 08             	mov    0x8(%ebp),%eax
77301e6a:	56                   	push   %esi
77301e6b:	50                   	push   %eax
77301e6c:	8b 85 e4 fe ff ff    	mov    0xfffffee4(%ebp),%eax
77301e72:	50                   	push   %eax
77301e73:	e8 18 fa ff ff       	call   77301890 <_getInterfaceInfoByIndex>
        if( NT_SUCCESS(status) ) 
77301e78:	83 c4 10             	add    $0x10,%esp
77301e7b:	89 c3                	mov    %eax,%ebx
77301e7d:	85 c0                	test   %eax,%eax
77301e7f:	78 15                	js     77301e96 <_getInterfacePhysicalByIndex+0x56>
            getInterfacePhysicalFromInfo( &info, len, addr, type );
77301e81:	8b 45 14             	mov    0x14(%ebp),%eax
77301e84:	8b 4d 0c             	mov    0xc(%ebp),%ecx
77301e87:	50                   	push   %eax
77301e88:	8b 45 10             	mov    0x10(%ebp),%eax
77301e8b:	50                   	push   %eax
77301e8c:	51                   	push   %ecx
77301e8d:	56                   	push   %esi
77301e8e:	e8 fd fe ff ff       	call   77301d90 <_getInterfacePhysicalFromInfo>
77301e93:	83 c4 10             	add    $0x10,%esp
        closeTcpFile( tcpFile );
77301e96:	83 ec 0c             	sub    $0xc,%esp
77301e99:	8b 95 e4 fe ff ff    	mov    0xfffffee4(%ebp),%edx
77301e9f:	52                   	push   %edx
77301ea0:	e8 bb f3 ff ff       	call   77301260 <_closeTcpFile>
77301ea5:	83 c4 10             	add    $0x10,%esp
    }

    return status;
}
77301ea8:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
77301eab:	89 d8                	mov    %ebx,%eax
77301ead:	5b                   	pop    %ebx
77301eae:	5e                   	pop    %esi
77301eaf:	5d                   	pop    %ebp
77301eb0:	c3                   	ret    
77301eb1:	eb 0d                	jmp    77301ec0 <_getInterfaceMtuByName>
77301eb3:	90                   	nop    
77301eb4:	90                   	nop    
77301eb5:	90                   	nop    
77301eb6:	90                   	nop    
77301eb7:	90                   	nop    
77301eb8:	90                   	nop    
77301eb9:	90                   	nop    
77301eba:	90                   	nop    
77301ebb:	90                   	nop    
77301ebc:	90                   	nop    
77301ebd:	90                   	nop    
77301ebe:	90                   	nop    
77301ebf:	90                   	nop    

77301ec0 <_getInterfaceMtuByName>:

DWORD getInterfaceMtuByName(const char *name, PDWORD mtu) {
77301ec0:	55                   	push   %ebp
77301ec1:	89 e5                	mov    %esp,%ebp
77301ec3:	83 ec 0c             	sub    $0xc,%esp
    *mtu = getAddrByIndexOrName( (char *)name, 0, IFMtu );
77301ec6:	8b 45 08             	mov    0x8(%ebp),%eax
77301ec9:	6a 03                	push   $0x3
77301ecb:	6a 00                	push   $0x0
77301ecd:	50                   	push   %eax
77301ece:	e8 8d fd ff ff       	call   77301c60 <_getAddrByIndexOrName>
77301ed3:	8b 55 0c             	mov    0xc(%ebp),%edx
77301ed6:	89 02                	mov    %eax,(%edx)
    return STATUS_SUCCESS;
}
77301ed8:	31 c0                	xor    %eax,%eax
77301eda:	c9                   	leave  
77301edb:	c3                   	ret    
77301edc:	8d 74 26 00          	lea    0x0(%esi),%esi

77301ee0 <_getInterfaceMtuByIndex>:

DWORD getInterfaceMtuByIndex(DWORD index, PDWORD mtu) {
77301ee0:	55                   	push   %ebp
77301ee1:	89 e5                	mov    %esp,%ebp
77301ee3:	83 ec 0c             	sub    $0xc,%esp
    *mtu = getAddrByIndexOrName( 0, index, IFMtu );
77301ee6:	8b 55 08             	mov    0x8(%ebp),%edx
77301ee9:	6a 03                	push   $0x3
77301eeb:	52                   	push   %edx
77301eec:	6a 00                	push   $0x0
77301eee:	e8 6d fd ff ff       	call   77301c60 <_getAddrByIndexOrName>
77301ef3:	8b 55 0c             	mov    0xc(%ebp),%edx
77301ef6:	89 02                	mov    %eax,(%edx)
    return STATUS_SUCCESS;
}
77301ef8:	31 c0                	xor    %eax,%eax
77301efa:	c9                   	leave  
77301efb:	c3                   	ret    
77301efc:	8d 74 26 00          	lea    0x0(%esi),%esi

77301f00 <_getInterfaceStatusByName>:

DWORD getInterfaceStatusByName(const char *name, PDWORD status) {
77301f00:	55                   	push   %ebp
77301f01:	89 e5                	mov    %esp,%ebp
77301f03:	83 ec 0c             	sub    $0xc,%esp
    *status = getAddrByIndexOrName( (char *)name, 0, IFStatus );
77301f06:	8b 4d 08             	mov    0x8(%ebp),%ecx
77301f09:	6a 04                	push   $0x4
77301f0b:	6a 00                	push   $0x0
77301f0d:	51                   	push   %ecx
77301f0e:	e8 4d fd ff ff       	call   77301c60 <_getAddrByIndexOrName>
77301f13:	8b 55 0c             	mov    0xc(%ebp),%edx
77301f16:	89 02                	mov    %eax,(%edx)
    return STATUS_SUCCESS;
}
77301f18:	31 c0                	xor    %eax,%eax
77301f1a:	c9                   	leave  
77301f1b:	c3                   	ret    
77301f1c:	8d 74 26 00          	lea    0x0(%esi),%esi

77301f20 <_getInterfaceStatusByIndex>:

DWORD getInterfaceStatusByIndex(DWORD index, PDWORD status)
{
77301f20:	55                   	push   %ebp
77301f21:	89 e5                	mov    %esp,%ebp
77301f23:	83 ec 0c             	sub    $0xc,%esp
    *status = getAddrByIndexOrName( 0, index, IFStatus );
77301f26:	8b 45 08             	mov    0x8(%ebp),%eax
77301f29:	6a 04                	push   $0x4
77301f2b:	50                   	push   %eax
77301f2c:	6a 00                	push   $0x0
77301f2e:	e8 2d fd ff ff       	call   77301c60 <_getAddrByIndexOrName>
77301f33:	8b 55 0c             	mov    0xc(%ebp),%edx
77301f36:	89 02                	mov    %eax,(%edx)
    return STATUS_SUCCESS;
}
77301f38:	31 c0                	xor    %eax,%eax
77301f3a:	c9                   	leave  
77301f3b:	c3                   	ret    
77301f3c:	8d 74 26 00          	lea    0x0(%esi),%esi

77301f40 <_getInterfaceEntryByName>:

DWORD getInterfaceEntryByName(const char *name, PMIB_IFROW entry)
{
77301f40:	55                   	push   %ebp
77301f41:	89 e5                	mov    %esp,%ebp
77301f43:	53                   	push   %ebx
77301f44:	81 ec 30 01 00 00    	sub    $0x130,%esp
    HANDLE tcpFile;
    IFInfo info;
    NTSTATUS status = openTcpFile( &tcpFile );
77301f4a:	8d 85 e4 fe ff ff    	lea    0xfffffee4(%ebp),%eax
77301f50:	50                   	push   %eax
77301f51:	e8 9a f2 ff ff       	call   773011f0 <_openTcpFile>

    DPRINT("Called.\n");

    if( NT_SUCCESS(status) ) {
77301f56:	83 c4 10             	add    $0x10,%esp
77301f59:	89 c3                	mov    %eax,%ebx
77301f5b:	85 c0                	test   %eax,%eax
77301f5d:	78 52                	js     77301fb1 <_getInterfaceEntryByName+0x71>
        status = getInterfaceInfoByName( tcpFile, (char *)name, &info );
77301f5f:	50                   	push   %eax
77301f60:	8d 85 e8 fe ff ff    	lea    0xfffffee8(%ebp),%eax
77301f66:	8b 9d e4 fe ff ff    	mov    0xfffffee4(%ebp),%ebx
77301f6c:	50                   	push   %eax
77301f6d:	8b 45 08             	mov    0x8(%ebp),%eax
77301f70:	50                   	push   %eax
77301f71:	53                   	push   %ebx
77301f72:	e8 a9 f9 ff ff       	call   77301920 <_getInterfaceInfoByName>
        
        if( NT_SUCCESS(status) ) {
77301f77:	83 c4 10             	add    $0x10,%esp
77301f7a:	89 c3                	mov    %eax,%ebx
77301f7c:	85 c0                	test   %eax,%eax
77301f7e:	78 1f                	js     77301f9f <_getInterfaceEntryByName+0x5f>
            memcpy( &entry->wszName[MAX_INTERFACE_NAME_LEN],
77301f80:	8b 55 0c             	mov    0xc(%ebp),%edx
77301f83:	8d 85 f0 fe ff ff    	lea    0xfffffef0(%ebp),%eax
77301f89:	81 c2 00 02 00 00    	add    $0x200,%edx
77301f8f:	51                   	push   %ecx
77301f90:	68 e8 00 00 00       	push   $0xe8
77301f95:	50                   	push   %eax
77301f96:	52                   	push   %edx
77301f97:	e8 94 59 00 00       	call   77307930 <_memcpy>
77301f9c:	83 c4 10             	add    $0x10,%esp
                    &info.if_info,
                    sizeof(info.if_info) );
        }
        
        closeTcpFile( tcpFile );
77301f9f:	83 ec 0c             	sub    $0xc,%esp
77301fa2:	8b 85 e4 fe ff ff    	mov    0xfffffee4(%ebp),%eax
77301fa8:	50                   	push   %eax
77301fa9:	e8 b2 f2 ff ff       	call   77301260 <_closeTcpFile>
77301fae:	83 c4 10             	add    $0x10,%esp
    }

    return status;
}
77301fb1:	89 d8                	mov    %ebx,%eax
77301fb3:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
77301fb6:	c9                   	leave  
77301fb7:	c3                   	ret    
77301fb8:	90                   	nop    
77301fb9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

77301fc0 <_getInterfaceEntryByIndex>:

DWORD getInterfaceEntryByIndex(DWORD index, PMIB_IFROW entry)
{
77301fc0:	55                   	push   %ebp
77301fc1:	89 e5                	mov    %esp,%ebp
77301fc3:	53                   	push   %ebx
77301fc4:	81 ec 30 01 00 00    	sub    $0x130,%esp
    HANDLE tcpFile;
    IFInfo info;
    NTSTATUS status = openTcpFile( &tcpFile );
77301fca:	8d 85 e4 fe ff ff    	lea    0xfffffee4(%ebp),%eax
77301fd0:	50                   	push   %eax
77301fd1:	e8 1a f2 ff ff       	call   773011f0 <_openTcpFile>

    DPRINT("Called.\n");

    if( NT_SUCCESS(status) ) {
77301fd6:	83 c4 10             	add    $0x10,%esp
77301fd9:	89 c3                	mov    %eax,%ebx
77301fdb:	85 c0                	test   %eax,%eax
77301fdd:	78 52                	js     77302031 <_getInterfaceEntryByIndex+0x71>
        status = getInterfaceInfoByIndex( tcpFile, index, &info );
77301fdf:	50                   	push   %eax
77301fe0:	8d 85 e8 fe ff ff    	lea    0xfffffee8(%ebp),%eax
77301fe6:	8b 9d e4 fe ff ff    	mov    0xfffffee4(%ebp),%ebx
77301fec:	50                   	push   %eax
77301fed:	8b 45 08             	mov    0x8(%ebp),%eax
77301ff0:	50                   	push   %eax
77301ff1:	53                   	push   %ebx
77301ff2:	e8 99 f8 ff ff       	call   77301890 <_getInterfaceInfoByIndex>
        
        if( NT_SUCCESS(status) ) {
77301ff7:	83 c4 10             	add    $0x10,%esp
77301ffa:	89 c3                	mov    %eax,%ebx
77301ffc:	85 c0                	test   %eax,%eax
77301ffe:	78 1f                	js     7730201f <_getInterfaceEntryByIndex+0x5f>
            memcpy( &entry->wszName[MAX_INTERFACE_NAME_LEN],
77302000:	8b 55 0c             	mov    0xc(%ebp),%edx
77302003:	8d 85 f0 fe ff ff    	lea    0xfffffef0(%ebp),%eax
77302009:	81 c2 00 02 00 00    	add    $0x200,%edx
7730200f:	51                   	push   %ecx
77302010:	68 e8 00 00 00       	push   $0xe8
77302015:	50                   	push   %eax
77302016:	52                   	push   %edx
77302017:	e8 14 59 00 00       	call   77307930 <_memcpy>
7730201c:	83 c4 10             	add    $0x10,%esp
                    &info.if_info,
                    sizeof(info.if_info) );
        }
        
        closeTcpFile( tcpFile );
7730201f:	83 ec 0c             	sub    $0xc,%esp
77302022:	8b 85 e4 fe ff ff    	mov    0xfffffee4(%ebp),%eax
77302028:	50                   	push   %eax
77302029:	e8 32 f2 ff ff       	call   77301260 <_closeTcpFile>
7730202e:	83 c4 10             	add    $0x10,%esp
    }

    return status;
}
77302031:	89 d8                	mov    %ebx,%eax
77302033:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
77302036:	c9                   	leave  
77302037:	c3                   	ret    
77302038:	90                   	nop    
77302039:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

77302040 <_toIPAddressString>:

char *toIPAddressString(unsigned int addr, char string[16])
{
77302040:	55                   	push   %ebp
77302041:	89 e5                	mov    %esp,%ebp
77302043:	53                   	push   %ebx
77302044:	50                   	push   %eax
77302045:	8b 5d 0c             	mov    0xc(%ebp),%ebx
  if (string) {
77302048:	85 db                	test   %ebx,%ebx
7730204a:	74 1d                	je     77302069 <_toIPAddressString+0x29>
    struct in_addr iAddr;

    iAddr.s_addr = addr;
    /* extra-anal, just to make auditors happy */
    strncpy(string, inet_ntoa(iAddr), 16);
7730204c:	50                   	push   %eax
7730204d:	6a 10                	push   $0x10
7730204f:	50                   	push   %eax
77302050:	8b 45 08             	mov    0x8(%ebp),%eax
77302053:	50                   	push   %eax
77302054:	e8 87 58 00 00       	call   773078e0 <_inet_ntoa@4>
77302059:	89 04 24             	mov    %eax,(%esp)
7730205c:	53                   	push   %ebx
7730205d:	e8 de 58 00 00       	call   77307940 <_strncpy>
    string[16] = '\0';
77302062:	c6 43 10 00          	movb   $0x0,0x10(%ebx)
77302066:	83 c4 10             	add    $0x10,%esp
  }
  return string;
}
77302069:	89 d8                	mov    %ebx,%eax
7730206b:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
7730206e:	c9                   	leave  
7730206f:	c3                   	ret    

77302070 <_isIpEntity>:
77302070:	55                   	push   %ebp
77302071:	89 e5                	mov    %esp,%ebp
77302073:	83 ec 48             	sub    $0x48,%esp
77302076:	8b 45 0c             	mov    0xc(%ebp),%eax
77302079:	c7 45 d0 00 01 00 00 	movl   $0x100,0xffffffd0(%ebp)
77302080:	c7 45 d4 00 01 00 00 	movl   $0x100,0xffffffd4(%ebp)
77302087:	c7 45 d8 01 00 00 00 	movl   $0x1,0xffffffd8(%ebp)
7730208e:	8b 50 04             	mov    0x4(%eax),%edx
77302091:	8b 00                	mov    (%eax),%eax
77302093:	89 45 c8             	mov    %eax,0xffffffc8(%ebp)
77302096:	8d 45 c4             	lea    0xffffffc4(%ebp),%eax
77302099:	89 55 cc             	mov    %edx,0xffffffcc(%ebp)
7730209c:	6a 00                	push   $0x0
7730209e:	50                   	push   %eax
7730209f:	8d 45 c0             	lea    0xffffffc0(%ebp),%eax
773020a2:	6a 04                	push   $0x4
773020a4:	50                   	push   %eax
773020a5:	8d 45 c8             	lea    0xffffffc8(%ebp),%eax
773020a8:	6a 24                	push   $0x24
773020aa:	50                   	push   %eax
773020ab:	68 03 00 12 00       	push   $0x120003
773020b0:	8b 45 08             	mov    0x8(%ebp),%eax
773020b3:	50                   	push   %eax
773020b4:	e8 67 33 00 00       	call   77305420 <_DeviceIoControl@32>
773020b9:	31 d2                	xor    %edx,%edx
773020bb:	85 c0                	test   %eax,%eax
773020bd:	78 09                	js     773020c8 <_isIpEntity+0x58>
773020bf:	81 7d c0 03 03 00 00 	cmpl   $0x303,0xffffffc0(%ebp)
773020c6:	74 08                	je     773020d0 <_isIpEntity+0x60>
773020c8:	89 d0                	mov    %edx,%eax
773020ca:	c9                   	leave  
773020cb:	c3                   	ret    
773020cc:	8d 74 26 00          	lea    0x0(%esi),%esi
773020d0:	b2 01                	mov    $0x1,%dl
773020d2:	c9                   	leave  
773020d3:	89 d0                	mov    %edx,%eax
773020d5:	c3                   	ret    
773020d6:	8d 76 00             	lea    0x0(%esi),%esi
773020d9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

773020e0 <_getNthIpEntity>:
773020e0:	55                   	push   %ebp
773020e1:	89 e5                	mov    %esp,%ebp
773020e3:	57                   	push   %edi
773020e4:	56                   	push   %esi
773020e5:	53                   	push   %ebx
773020e6:	83 ec 10             	sub    $0x10,%esp
773020e9:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
773020ec:	8b 7d 08             	mov    0x8(%ebp),%edi
773020ef:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
773020f6:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
773020fd:	50                   	push   %eax
773020fe:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
77302101:	31 f6                	xor    %esi,%esi
77302103:	50                   	push   %eax
77302104:	57                   	push   %edi
77302105:	e8 16 f3 ff ff       	call   77301420 <_tdiGetEntityIDSet>
7730210a:	83 c4 10             	add    $0x10,%esp
7730210d:	85 c0                	test   %eax,%eax
7730210f:	78 44                	js     77302155 <_getNthIpEntity+0x75>
77302111:	31 db                	xor    %ebx,%ebx
77302113:	3b 5d f0             	cmp    0xfffffff0(%ebp),%ebx
77302116:	73 22                	jae    7730213a <_getNthIpEntity+0x5a>
77302118:	51                   	push   %ecx
77302119:	51                   	push   %ecx
7730211a:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
7730211d:	8d 04 d8             	lea    (%eax,%ebx,8),%eax
77302120:	50                   	push   %eax
77302121:	57                   	push   %edi
77302122:	e8 49 ff ff ff       	call   77302070 <_isIpEntity>
77302127:	83 c4 10             	add    $0x10,%esp
7730212a:	85 c0                	test   %eax,%eax
7730212c:	74 06                	je     77302134 <_getNthIpEntity+0x54>
7730212e:	3b 75 0c             	cmp    0xc(%ebp),%esi
77302131:	74 0c                	je     7730213f <_getNthIpEntity+0x5f>
77302133:	46                   	inc    %esi
77302134:	43                   	inc    %ebx
77302135:	3b 5d f0             	cmp    0xfffffff0(%ebp),%ebx
77302138:	72 de                	jb     77302118 <_getNthIpEntity+0x38>
7730213a:	3b 75 0c             	cmp    0xc(%ebp),%esi
7730213d:	75 05                	jne    77302144 <_getNthIpEntity+0x64>
7730213f:	3b 5d f0             	cmp    0xfffffff0(%ebp),%ebx
77302142:	72 19                	jb     7730215d <_getNthIpEntity+0x7d>
77302144:	83 ec 0c             	sub    $0xc,%esp
77302147:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
7730214a:	52                   	push   %edx
7730214b:	e8 50 f2 ff ff       	call   773013a0 <_tdiFreeThingSet>
77302150:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
77302155:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77302158:	5b                   	pop    %ebx
77302159:	5e                   	pop    %esi
7730215a:	5f                   	pop    %edi
7730215b:	5d                   	pop    %ebp
7730215c:	c3                   	ret    
7730215d:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
77302160:	8b 4d 10             	mov    0x10(%ebp),%ecx
77302163:	83 ec 0c             	sub    $0xc,%esp
77302166:	8b 14 d8             	mov    (%eax,%ebx,8),%edx
77302169:	89 11                	mov    %edx,(%ecx)
7730216b:	8b 54 d8 04          	mov    0x4(%eax,%ebx,8),%edx
7730216f:	89 51 04             	mov    %edx,0x4(%ecx)
77302172:	50                   	push   %eax
77302173:	e8 28 f2 ff ff       	call   773013a0 <_tdiFreeThingSet>
77302178:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
7730217b:	31 c0                	xor    %eax,%eax
7730217d:	5b                   	pop    %ebx
7730217e:	5e                   	pop    %esi
7730217f:	5f                   	pop    %edi
77302180:	5d                   	pop    %ebp
77302181:	c3                   	ret    
77302182:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
77302189:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77302190 <_tdiGetMibForIpEntity>:
77302190:	55                   	push   %ebp
77302191:	31 c0                	xor    %eax,%eax
77302193:	89 e5                	mov    %esp,%ebp
77302195:	b9 09 00 00 00       	mov    $0x9,%ecx
7730219a:	fc                   	cld    
7730219b:	57                   	push   %edi
7730219c:	8d 7d c8             	lea    0xffffffc8(%ebp),%edi
7730219f:	53                   	push   %ebx
773021a0:	83 ec 44             	sub    $0x44,%esp
773021a3:	f3 ab                	repz stos %eax,%es:(%edi)
773021a5:	8b 5d 10             	mov    0x10(%ebp),%ebx
773021a8:	6a 5c                	push   $0x5c
773021aa:	6a 00                	push   $0x0
773021ac:	53                   	push   %ebx
773021ad:	e8 de 57 00 00       	call   77307990 <_memset>
773021b2:	8b 45 0c             	mov    0xc(%ebp),%eax
773021b5:	c7 45 d0 00 02 00 00 	movl   $0x200,0xffffffd0(%ebp)
773021bc:	c7 45 d4 00 01 00 00 	movl   $0x100,0xffffffd4(%ebp)
773021c3:	c7 45 d8 01 00 00 00 	movl   $0x1,0xffffffd8(%ebp)
773021ca:	8b 50 04             	mov    0x4(%eax),%edx
773021cd:	8b 00                	mov    (%eax),%eax
773021cf:	89 45 c8             	mov    %eax,0xffffffc8(%ebp)
773021d2:	8d 45 c4             	lea    0xffffffc4(%ebp),%eax
773021d5:	6a 00                	push   $0x0
773021d7:	50                   	push   %eax
773021d8:	8d 45 c8             	lea    0xffffffc8(%ebp),%eax
773021db:	6a 5c                	push   $0x5c
773021dd:	53                   	push   %ebx
773021de:	8b 5d 08             	mov    0x8(%ebp),%ebx
773021e1:	6a 24                	push   $0x24
773021e3:	89 55 cc             	mov    %edx,0xffffffcc(%ebp)
773021e6:	50                   	push   %eax
773021e7:	68 03 00 12 00       	push   $0x120003
773021ec:	53                   	push   %ebx
773021ed:	e8 2e 32 00 00       	call   77305420 <_DeviceIoControl@32>
773021f2:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
773021f5:	5b                   	pop    %ebx
773021f6:	5f                   	pop    %edi
773021f7:	5d                   	pop    %ebp
773021f8:	c3                   	ret    
773021f9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

77302200 <_tdiGetRoutesForIpEntity>:
77302200:	55                   	push   %ebp
77302201:	89 e5                	mov    %esp,%ebp
77302203:	83 ec 14             	sub    $0x14,%esp
77302206:	8b 45 14             	mov    0x14(%ebp),%eax
77302209:	50                   	push   %eax
7730220a:	8b 45 10             	mov    0x10(%ebp),%eax
7730220d:	50                   	push   %eax
7730220e:	8b 45 0c             	mov    0xc(%ebp),%eax
77302211:	6a 34                	push   $0x34
77302213:	6a 00                	push   $0x0
77302215:	8b 00                	mov    (%eax),%eax
77302217:	50                   	push   %eax
77302218:	8b 45 08             	mov    0x8(%ebp),%eax
7730221b:	68 01 01 00 00       	push   $0x101
77302220:	68 00 01 00 00       	push   $0x100
77302225:	68 00 02 00 00       	push   $0x200
7730222a:	50                   	push   %eax
7730222b:	e8 50 f0 ff ff       	call   77301280 <_tdiGetSetOfThings>
77302230:	c9                   	leave  
77302231:	c3                   	ret    
77302232:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
77302239:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77302240 <_tdiGetIpAddrsForIpEntity>:
77302240:	55                   	push   %ebp
77302241:	89 e5                	mov    %esp,%ebp
77302243:	83 ec 14             	sub    $0x14,%esp
77302246:	8b 4d 14             	mov    0x14(%ebp),%ecx
77302249:	8b 55 10             	mov    0x10(%ebp),%edx
7730224c:	8b 45 0c             	mov    0xc(%ebp),%eax
7730224f:	51                   	push   %ecx
77302250:	52                   	push   %edx
77302251:	6a 1c                	push   $0x1c
77302253:	6a 00                	push   $0x0
77302255:	8b 00                	mov    (%eax),%eax
77302257:	50                   	push   %eax
77302258:	8b 45 08             	mov    0x8(%ebp),%eax
7730225b:	68 02 01 00 00       	push   $0x102
77302260:	68 00 01 00 00       	push   $0x100
77302265:	68 00 02 00 00       	push   $0x200
7730226a:	50                   	push   %eax
7730226b:	e8 10 f0 ff ff       	call   77301280 <_tdiGetSetOfThings>
77302270:	c9                   	leave  
77302271:	c3                   	ret    
77302272:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
77302279:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77302280 <_getInterfaceStatsByName>:
77302280:	55                   	push   %ebp
77302281:	b8 57 00 00 00       	mov    $0x57,%eax
77302286:	89 e5                	mov    %esp,%ebp
77302288:	8b 55 08             	mov    0x8(%ebp),%edx
7730228b:	85 d2                	test   %edx,%edx
7730228d:	74 09                	je     77302298 <_getInterfaceStatsByName+0x18>
7730228f:	83 7d 0c 01          	cmpl   $0x1,0xc(%ebp)
77302293:	19 c0                	sbb    %eax,%eax
77302295:	83 e0 57             	and    $0x57,%eax
77302298:	5d                   	pop    %ebp
77302299:	c3                   	ret    
7730229a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

773022a0 <_getInterfaceStatsByIndex>:
773022a0:	55                   	push   %ebp
773022a1:	b8 57 00 00 00       	mov    $0x57,%eax
773022a6:	89 e5                	mov    %esp,%ebp
773022a8:	5d                   	pop    %ebp
773022a9:	c3                   	ret    
773022aa:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

773022b0 <_getICMPStats>:
773022b0:	55                   	push   %ebp
773022b1:	b8 57 00 00 00       	mov    $0x57,%eax
773022b6:	89 e5                	mov    %esp,%ebp
773022b8:	57                   	push   %edi
773022b9:	56                   	push   %esi
773022ba:	53                   	push   %ebx
773022bb:	81 ec 2c 02 00 00    	sub    $0x22c,%esp
773022c1:	8b 75 08             	mov    0x8(%ebp),%esi
773022c4:	85 f6                	test   %esi,%esi
773022c6:	0f 84 1b 03 00 00    	je     773025e7 <_getICMPStats+0x337>
773022cc:	8b 4d 08             	mov    0x8(%ebp),%ecx
773022cf:	53                   	push   %ebx
773022d0:	6a 68                	push   $0x68
773022d2:	6a 00                	push   $0x0
773022d4:	51                   	push   %ecx
773022d5:	e8 b6 56 00 00       	call   77307990 <_memset>
773022da:	58                   	pop    %eax
773022db:	5a                   	pop    %edx
773022dc:	68 a0 a0 30 77       	push   $0x7730a0a0
773022e1:	68 a2 a0 30 77       	push   $0x7730a0a2
773022e6:	e8 b5 5c 00 00       	call   77307fa0 <_fopen>
773022eb:	83 c4 10             	add    $0x10,%esp
773022ee:	85 c0                	test   %eax,%eax
773022f0:	89 85 d0 fd ff ff    	mov    %eax,0xfffffdd0(%ebp)
773022f6:	0f 84 e9 02 00 00    	je     773025e5 <_getICMPStats+0x335>
773022fc:	a1 b1 a0 30 77       	mov    0x7730a0b1,%eax
77302301:	8d 9d d8 fd ff ff    	lea    0xfffffdd8(%ebp),%ebx
77302307:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
7730230a:	66 a1 b5 a0 30 77    	mov    0x7730a0b5,%ax
77302310:	66 89 45 dc          	mov    %ax,0xffffffdc(%ebp)
77302314:	50                   	push   %eax
77302315:	68 00 02 00 00       	push   $0x200
7730231a:	6a 00                	push   $0x0
7730231c:	53                   	push   %ebx
7730231d:	8d 7d d8             	lea    0xffffffd8(%ebp),%edi
77302320:	e8 6b 56 00 00       	call   77307990 <_memset>
77302325:	83 c4 10             	add    $0x10,%esp
77302328:	50                   	push   %eax
77302329:	8b 85 d0 fd ff ff    	mov    0xfffffdd0(%ebp),%eax
7730232f:	50                   	push   %eax
77302330:	68 00 02 00 00       	push   $0x200
77302335:	53                   	push   %ebx
77302336:	e8 55 5c 00 00       	call   77307f90 <_fgets>
7730233b:	83 c4 10             	add    $0x10,%esp
7730233e:	85 c0                	test   %eax,%eax
77302340:	0f 84 8d 02 00 00    	je     773025d3 <_getICMPStats+0x323>
_CRTIMP char* __cdecl	strlwr (char*);
_CRTIMP int __cdecl	strnicmp (const char*, const char*, size_t);
__CRT_INLINE int __cdecl
strncasecmp (const char * __sz1, const char * __sz2, size_t __sizeMaxCompare)
  {return _strnicmp (__sz1, __sz2, __sizeMaxCompare);}
77302346:	50                   	push   %eax
77302347:	6a 05                	push   $0x5
77302349:	57                   	push   %edi
7730234a:	53                   	push   %ebx
7730234b:	e8 60 56 00 00       	call   773079b0 <__strnicmp>
77302350:	83 c4 10             	add    $0x10,%esp
77302353:	85 c0                	test   %eax,%eax
77302355:	75 d1                	jne    77302328 <_getICMPStats+0x78>
77302357:	8b 8d d0 fd ff ff    	mov    0xfffffdd0(%ebp),%ecx
7730235d:	56                   	push   %esi
7730235e:	51                   	push   %ecx
7730235f:	68 00 02 00 00       	push   $0x200
77302364:	53                   	push   %ebx
77302365:	e8 26 5c 00 00       	call   77307f90 <_fgets>
7730236a:	83 c4 10             	add    $0x10,%esp
7730236d:	89 c6                	mov    %eax,%esi
7730236f:	85 c0                	test   %eax,%eax
77302371:	0f 84 5c 02 00 00    	je     773025d3 <_getICMPStats+0x323>
_CRTIMP char* __cdecl	strlwr (char*);
_CRTIMP int __cdecl	strnicmp (const char*, const char*, size_t);
__CRT_INLINE int __cdecl
strncasecmp (const char * __sz1, const char * __sz2, size_t __sizeMaxCompare)
  {return _strnicmp (__sz1, __sz2, __sizeMaxCompare);}
77302377:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
7730237a:	52                   	push   %edx
7730237b:	6a 05                	push   $0x5
7730237d:	50                   	push   %eax
7730237e:	53                   	push   %ebx
7730237f:	e8 2c 56 00 00       	call   773079b0 <__strnicmp>
77302384:	83 c4 10             	add    $0x10,%esp
77302387:	85 c0                	test   %eax,%eax
77302389:	0f 85 44 02 00 00    	jne    773025d3 <_getICMPStats+0x323>
7730238f:	83 c6 06             	add    $0x6,%esi
77302392:	0f 84 3b 02 00 00    	je     773025d3 <_getICMPStats+0x323>
77302398:	80 3e 00             	cmpb   $0x0,(%esi)
7730239b:	0f 85 72 02 00 00    	jne    77302613 <_getICMPStats+0x363>
773023a1:	85 f6                	test   %esi,%esi
773023a3:	0f 84 2a 02 00 00    	je     773025d3 <_getICMPStats+0x323>
773023a9:	80 3e 00             	cmpb   $0x0,(%esi)
773023ac:	0f 85 3d 02 00 00    	jne    773025ef <_getICMPStats+0x33f>
773023b2:	85 f6                	test   %esi,%esi
773023b4:	0f 84 19 02 00 00    	je     773025d3 <_getICMPStats+0x323>
773023ba:	80 3e 00             	cmpb   $0x0,(%esi)
773023bd:	0f 85 73 02 00 00    	jne    77302636 <_getICMPStats+0x386>
773023c3:	85 f6                	test   %esi,%esi
773023c5:	0f 84 08 02 00 00    	je     773025d3 <_getICMPStats+0x323>
773023cb:	80 3e 00             	cmpb   $0x0,(%esi)
773023ce:	0f 85 86 02 00 00    	jne    7730265a <_getICMPStats+0x3aa>
773023d4:	85 f6                	test   %esi,%esi
773023d6:	0f 84 f7 01 00 00    	je     773025d3 <_getICMPStats+0x323>
773023dc:	80 3e 00             	cmpb   $0x0,(%esi)
773023df:	0f 85 99 02 00 00    	jne    7730267e <_getICMPStats+0x3ce>
773023e5:	85 f6                	test   %esi,%esi
773023e7:	0f 84 e6 01 00 00    	je     773025d3 <_getICMPStats+0x323>
773023ed:	80 3e 00             	cmpb   $0x0,(%esi)
773023f0:	0f 85 ac 02 00 00    	jne    773026a2 <_getICMPStats+0x3f2>
773023f6:	85 f6                	test   %esi,%esi
773023f8:	0f 84 d5 01 00 00    	je     773025d3 <_getICMPStats+0x323>
773023fe:	80 3e 00             	cmpb   $0x0,(%esi)
77302401:	0f 85 bf 02 00 00    	jne    773026c6 <_getICMPStats+0x416>
77302407:	85 f6                	test   %esi,%esi
77302409:	0f 84 c4 01 00 00    	je     773025d3 <_getICMPStats+0x323>
7730240f:	80 3e 00             	cmpb   $0x0,(%esi)
77302412:	0f 85 d2 02 00 00    	jne    773026ea <_getICMPStats+0x43a>
77302418:	85 f6                	test   %esi,%esi
7730241a:	0f 84 b3 01 00 00    	je     773025d3 <_getICMPStats+0x323>
77302420:	80 3e 00             	cmpb   $0x0,(%esi)
77302423:	0f 85 e5 02 00 00    	jne    7730270e <_getICMPStats+0x45e>
77302429:	85 f6                	test   %esi,%esi
7730242b:	0f 84 a2 01 00 00    	je     773025d3 <_getICMPStats+0x323>
77302431:	80 3e 00             	cmpb   $0x0,(%esi)
77302434:	0f 85 f8 02 00 00    	jne    77302732 <_getICMPStats+0x482>
7730243a:	85 f6                	test   %esi,%esi
7730243c:	0f 84 91 01 00 00    	je     773025d3 <_getICMPStats+0x323>
77302442:	80 3e 00             	cmpb   $0x0,(%esi)
77302445:	0f 85 0b 03 00 00    	jne    77302756 <_getICMPStats+0x4a6>
7730244b:	85 f6                	test   %esi,%esi
7730244d:	0f 84 80 01 00 00    	je     773025d3 <_getICMPStats+0x323>
77302453:	80 3e 00             	cmpb   $0x0,(%esi)
77302456:	0f 85 1e 03 00 00    	jne    7730277a <_getICMPStats+0x4ca>
7730245c:	85 f6                	test   %esi,%esi
7730245e:	0f 84 6f 01 00 00    	je     773025d3 <_getICMPStats+0x323>
77302464:	80 3e 00             	cmpb   $0x0,(%esi)
77302467:	0f 85 31 03 00 00    	jne    7730279e <_getICMPStats+0x4ee>
7730246d:	85 f6                	test   %esi,%esi
7730246f:	0f 84 5e 01 00 00    	je     773025d3 <_getICMPStats+0x323>
77302475:	80 3e 00             	cmpb   $0x0,(%esi)
77302478:	0f 85 44 03 00 00    	jne    773027c2 <_getICMPStats+0x512>
7730247e:	85 f6                	test   %esi,%esi
77302480:	0f 84 4d 01 00 00    	je     773025d3 <_getICMPStats+0x323>
77302486:	80 3e 00             	cmpb   $0x0,(%esi)
77302489:	74 1f                	je     773024aa <_getICMPStats+0x1fa>
7730248b:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
77302491:	51                   	push   %ecx
77302492:	6a 0a                	push   $0xa
77302494:	50                   	push   %eax
77302495:	56                   	push   %esi
77302496:	e8 05 55 00 00       	call   773079a0 <_strtoul>
7730249b:	8b 55 08             	mov    0x8(%ebp),%edx
7730249e:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
773024a4:	83 c4 10             	add    $0x10,%esp
773024a7:	89 42 3c             	mov    %eax,0x3c(%edx)
773024aa:	85 f6                	test   %esi,%esi
773024ac:	0f 84 21 01 00 00    	je     773025d3 <_getICMPStats+0x323>
773024b2:	80 3e 00             	cmpb   $0x0,(%esi)
773024b5:	0f 85 2b 03 00 00    	jne    773027e6 <_getICMPStats+0x536>
773024bb:	85 f6                	test   %esi,%esi
773024bd:	0f 84 10 01 00 00    	je     773025d3 <_getICMPStats+0x323>
773024c3:	80 3e 00             	cmpb   $0x0,(%esi)
773024c6:	74 1f                	je     773024e7 <_getICMPStats+0x237>
773024c8:	50                   	push   %eax
773024c9:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
773024cf:	6a 0a                	push   $0xa
773024d1:	50                   	push   %eax
773024d2:	56                   	push   %esi
773024d3:	e8 c8 54 00 00       	call   773079a0 <_strtoul>
773024d8:	8b 55 08             	mov    0x8(%ebp),%edx
773024db:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
773024e1:	83 c4 10             	add    $0x10,%esp
773024e4:	89 42 44             	mov    %eax,0x44(%edx)
773024e7:	85 f6                	test   %esi,%esi
773024e9:	0f 84 e4 00 00 00    	je     773025d3 <_getICMPStats+0x323>
773024ef:	80 3e 00             	cmpb   $0x0,(%esi)
773024f2:	0f 85 36 03 00 00    	jne    7730282e <_getICMPStats+0x57e>
773024f8:	85 f6                	test   %esi,%esi
773024fa:	0f 84 d3 00 00 00    	je     773025d3 <_getICMPStats+0x323>
77302500:	80 3e 00             	cmpb   $0x0,(%esi)
77302503:	0f 85 01 03 00 00    	jne    7730280a <_getICMPStats+0x55a>
77302509:	85 f6                	test   %esi,%esi
7730250b:	0f 84 c2 00 00 00    	je     773025d3 <_getICMPStats+0x323>
77302511:	80 3e 00             	cmpb   $0x0,(%esi)
77302514:	74 1f                	je     77302535 <_getICMPStats+0x285>
77302516:	50                   	push   %eax
77302517:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
7730251d:	6a 0a                	push   $0xa
7730251f:	50                   	push   %eax
77302520:	56                   	push   %esi
77302521:	e8 7a 54 00 00       	call   773079a0 <_strtoul>
77302526:	8b 55 08             	mov    0x8(%ebp),%edx
77302529:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
7730252f:	83 c4 10             	add    $0x10,%esp
77302532:	89 42 54             	mov    %eax,0x54(%edx)
77302535:	85 f6                	test   %esi,%esi
77302537:	0f 84 96 00 00 00    	je     773025d3 <_getICMPStats+0x323>
7730253d:	80 3e 00             	cmpb   $0x0,(%esi)
77302540:	74 1f                	je     77302561 <_getICMPStats+0x2b1>
77302542:	50                   	push   %eax
77302543:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
77302549:	6a 0a                	push   $0xa
7730254b:	50                   	push   %eax
7730254c:	56                   	push   %esi
7730254d:	e8 4e 54 00 00       	call   773079a0 <_strtoul>
77302552:	8b 55 08             	mov    0x8(%ebp),%edx
77302555:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
7730255b:	83 c4 10             	add    $0x10,%esp
7730255e:	89 42 58             	mov    %eax,0x58(%edx)
77302561:	85 f6                	test   %esi,%esi
77302563:	74 6e                	je     773025d3 <_getICMPStats+0x323>
77302565:	80 3e 00             	cmpb   $0x0,(%esi)
77302568:	74 1f                	je     77302589 <_getICMPStats+0x2d9>
7730256a:	50                   	push   %eax
7730256b:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
77302571:	6a 0a                	push   $0xa
77302573:	50                   	push   %eax
77302574:	56                   	push   %esi
77302575:	e8 26 54 00 00       	call   773079a0 <_strtoul>
7730257a:	8b 55 08             	mov    0x8(%ebp),%edx
7730257d:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
77302583:	83 c4 10             	add    $0x10,%esp
77302586:	89 42 5c             	mov    %eax,0x5c(%edx)
77302589:	85 f6                	test   %esi,%esi
7730258b:	74 46                	je     773025d3 <_getICMPStats+0x323>
7730258d:	80 3e 00             	cmpb   $0x0,(%esi)
77302590:	74 1f                	je     773025b1 <_getICMPStats+0x301>
77302592:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
77302598:	57                   	push   %edi
77302599:	6a 0a                	push   $0xa
7730259b:	50                   	push   %eax
7730259c:	56                   	push   %esi
7730259d:	e8 fe 53 00 00       	call   773079a0 <_strtoul>
773025a2:	8b 55 08             	mov    0x8(%ebp),%edx
773025a5:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
773025ab:	83 c4 10             	add    $0x10,%esp
773025ae:	89 42 60             	mov    %eax,0x60(%edx)
773025b1:	85 f6                	test   %esi,%esi
773025b3:	74 1e                	je     773025d3 <_getICMPStats+0x323>
773025b5:	80 3e 00             	cmpb   $0x0,(%esi)
773025b8:	74 19                	je     773025d3 <_getICMPStats+0x323>
773025ba:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
773025c0:	53                   	push   %ebx
773025c1:	6a 0a                	push   $0xa
773025c3:	50                   	push   %eax
773025c4:	56                   	push   %esi
773025c5:	e8 d6 53 00 00       	call   773079a0 <_strtoul>
773025ca:	8b 55 08             	mov    0x8(%ebp),%edx
773025cd:	83 c4 10             	add    $0x10,%esp
773025d0:	89 42 64             	mov    %eax,0x64(%edx)
773025d3:	83 ec 0c             	sub    $0xc,%esp
773025d6:	8b 8d d0 fd ff ff    	mov    0xfffffdd0(%ebp),%ecx
773025dc:	51                   	push   %ecx
773025dd:	e8 9e 59 00 00       	call   77307f80 <_fclose>
773025e2:	83 c4 10             	add    $0x10,%esp
773025e5:	31 c0                	xor    %eax,%eax
773025e7:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773025ea:	5b                   	pop    %ebx
773025eb:	5e                   	pop    %esi
773025ec:	5f                   	pop    %edi
773025ed:	5d                   	pop    %ebp
773025ee:	c3                   	ret    
773025ef:	50                   	push   %eax
773025f0:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
773025f6:	6a 0a                	push   $0xa
773025f8:	50                   	push   %eax
773025f9:	56                   	push   %esi
773025fa:	e8 a1 53 00 00       	call   773079a0 <_strtoul>
773025ff:	8b 55 08             	mov    0x8(%ebp),%edx
77302602:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
77302608:	83 c4 10             	add    $0x10,%esp
7730260b:	89 42 04             	mov    %eax,0x4(%edx)
7730260e:	e9 9f fd ff ff       	jmp    773023b2 <_getICMPStats+0x102>
77302613:	50                   	push   %eax
77302614:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
7730261a:	6a 0a                	push   $0xa
7730261c:	50                   	push   %eax
7730261d:	56                   	push   %esi
7730261e:	e8 7d 53 00 00       	call   773079a0 <_strtoul>
77302623:	8b 55 08             	mov    0x8(%ebp),%edx
77302626:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
7730262c:	83 c4 10             	add    $0x10,%esp
7730262f:	89 02                	mov    %eax,(%edx)
77302631:	e9 6b fd ff ff       	jmp    773023a1 <_getICMPStats+0xf1>
77302636:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
7730263c:	57                   	push   %edi
7730263d:	6a 0a                	push   $0xa
7730263f:	50                   	push   %eax
77302640:	56                   	push   %esi
77302641:	e8 5a 53 00 00       	call   773079a0 <_strtoul>
77302646:	8b 55 08             	mov    0x8(%ebp),%edx
77302649:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
7730264f:	83 c4 10             	add    $0x10,%esp
77302652:	89 42 08             	mov    %eax,0x8(%edx)
77302655:	e9 69 fd ff ff       	jmp    773023c3 <_getICMPStats+0x113>
7730265a:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
77302660:	53                   	push   %ebx
77302661:	6a 0a                	push   $0xa
77302663:	50                   	push   %eax
77302664:	56                   	push   %esi
77302665:	e8 36 53 00 00       	call   773079a0 <_strtoul>
7730266a:	8b 55 08             	mov    0x8(%ebp),%edx
7730266d:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
77302673:	83 c4 10             	add    $0x10,%esp
77302676:	89 42 0c             	mov    %eax,0xc(%edx)
77302679:	e9 56 fd ff ff       	jmp    773023d4 <_getICMPStats+0x124>
7730267e:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
77302684:	51                   	push   %ecx
77302685:	6a 0a                	push   $0xa
77302687:	50                   	push   %eax
77302688:	56                   	push   %esi
77302689:	e8 12 53 00 00       	call   773079a0 <_strtoul>
7730268e:	8b 55 08             	mov    0x8(%ebp),%edx
77302691:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
77302697:	83 c4 10             	add    $0x10,%esp
7730269a:	89 42 10             	mov    %eax,0x10(%edx)
7730269d:	e9 43 fd ff ff       	jmp    773023e5 <_getICMPStats+0x135>
773026a2:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
773026a8:	52                   	push   %edx
773026a9:	6a 0a                	push   $0xa
773026ab:	50                   	push   %eax
773026ac:	56                   	push   %esi
773026ad:	e8 ee 52 00 00       	call   773079a0 <_strtoul>
773026b2:	8b 55 08             	mov    0x8(%ebp),%edx
773026b5:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
773026bb:	83 c4 10             	add    $0x10,%esp
773026be:	89 42 14             	mov    %eax,0x14(%edx)
773026c1:	e9 30 fd ff ff       	jmp    773023f6 <_getICMPStats+0x146>
773026c6:	50                   	push   %eax
773026c7:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
773026cd:	6a 0a                	push   $0xa
773026cf:	50                   	push   %eax
773026d0:	56                   	push   %esi
773026d1:	e8 ca 52 00 00       	call   773079a0 <_strtoul>
773026d6:	8b 55 08             	mov    0x8(%ebp),%edx
773026d9:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
773026df:	83 c4 10             	add    $0x10,%esp
773026e2:	89 42 18             	mov    %eax,0x18(%edx)
773026e5:	e9 1d fd ff ff       	jmp    77302407 <_getICMPStats+0x157>
773026ea:	50                   	push   %eax
773026eb:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
773026f1:	6a 0a                	push   $0xa
773026f3:	50                   	push   %eax
773026f4:	56                   	push   %esi
773026f5:	e8 a6 52 00 00       	call   773079a0 <_strtoul>
773026fa:	8b 55 08             	mov    0x8(%ebp),%edx
773026fd:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
77302703:	83 c4 10             	add    $0x10,%esp
77302706:	89 42 20             	mov    %eax,0x20(%edx)
77302709:	e9 0a fd ff ff       	jmp    77302418 <_getICMPStats+0x168>
7730270e:	50                   	push   %eax
7730270f:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
77302715:	6a 0a                	push   $0xa
77302717:	50                   	push   %eax
77302718:	56                   	push   %esi
77302719:	e8 82 52 00 00       	call   773079a0 <_strtoul>
7730271e:	8b 55 08             	mov    0x8(%ebp),%edx
77302721:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
77302727:	83 c4 10             	add    $0x10,%esp
7730272a:	89 42 24             	mov    %eax,0x24(%edx)
7730272d:	e9 f7 fc ff ff       	jmp    77302429 <_getICMPStats+0x179>
77302732:	50                   	push   %eax
77302733:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
77302739:	6a 0a                	push   $0xa
7730273b:	50                   	push   %eax
7730273c:	56                   	push   %esi
7730273d:	e8 5e 52 00 00       	call   773079a0 <_strtoul>
77302742:	8b 55 08             	mov    0x8(%ebp),%edx
77302745:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
7730274b:	83 c4 10             	add    $0x10,%esp
7730274e:	89 42 28             	mov    %eax,0x28(%edx)
77302751:	e9 e4 fc ff ff       	jmp    7730243a <_getICMPStats+0x18a>
77302756:	50                   	push   %eax
77302757:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
7730275d:	6a 0a                	push   $0xa
7730275f:	50                   	push   %eax
77302760:	56                   	push   %esi
77302761:	e8 3a 52 00 00       	call   773079a0 <_strtoul>
77302766:	8b 55 08             	mov    0x8(%ebp),%edx
77302769:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
7730276f:	83 c4 10             	add    $0x10,%esp
77302772:	89 42 2c             	mov    %eax,0x2c(%edx)
77302775:	e9 d1 fc ff ff       	jmp    7730244b <_getICMPStats+0x19b>
7730277a:	50                   	push   %eax
7730277b:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
77302781:	6a 0a                	push   $0xa
77302783:	50                   	push   %eax
77302784:	56                   	push   %esi
77302785:	e8 16 52 00 00       	call   773079a0 <_strtoul>
7730278a:	8b 55 08             	mov    0x8(%ebp),%edx
7730278d:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
77302793:	83 c4 10             	add    $0x10,%esp
77302796:	89 42 30             	mov    %eax,0x30(%edx)
77302799:	e9 be fc ff ff       	jmp    7730245c <_getICMPStats+0x1ac>
7730279e:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
773027a4:	57                   	push   %edi
773027a5:	6a 0a                	push   $0xa
773027a7:	50                   	push   %eax
773027a8:	56                   	push   %esi
773027a9:	e8 f2 51 00 00       	call   773079a0 <_strtoul>
773027ae:	8b 55 08             	mov    0x8(%ebp),%edx
773027b1:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
773027b7:	83 c4 10             	add    $0x10,%esp
773027ba:	89 42 34             	mov    %eax,0x34(%edx)
773027bd:	e9 ab fc ff ff       	jmp    7730246d <_getICMPStats+0x1bd>
773027c2:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
773027c8:	53                   	push   %ebx
773027c9:	6a 0a                	push   $0xa
773027cb:	50                   	push   %eax
773027cc:	56                   	push   %esi
773027cd:	e8 ce 51 00 00       	call   773079a0 <_strtoul>
773027d2:	8b 55 08             	mov    0x8(%ebp),%edx
773027d5:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
773027db:	83 c4 10             	add    $0x10,%esp
773027de:	89 42 38             	mov    %eax,0x38(%edx)
773027e1:	e9 98 fc ff ff       	jmp    7730247e <_getICMPStats+0x1ce>
773027e6:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
773027ec:	52                   	push   %edx
773027ed:	6a 0a                	push   $0xa
773027ef:	50                   	push   %eax
773027f0:	56                   	push   %esi
773027f1:	e8 aa 51 00 00       	call   773079a0 <_strtoul>
773027f6:	8b 55 08             	mov    0x8(%ebp),%edx
773027f9:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
773027ff:	83 c4 10             	add    $0x10,%esp
77302802:	89 42 40             	mov    %eax,0x40(%edx)
77302805:	e9 b1 fc ff ff       	jmp    773024bb <_getICMPStats+0x20b>
7730280a:	50                   	push   %eax
7730280b:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
77302811:	6a 0a                	push   $0xa
77302813:	50                   	push   %eax
77302814:	56                   	push   %esi
77302815:	e8 86 51 00 00       	call   773079a0 <_strtoul>
7730281a:	8b 55 08             	mov    0x8(%ebp),%edx
7730281d:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
77302823:	83 c4 10             	add    $0x10,%esp
77302826:	89 42 4c             	mov    %eax,0x4c(%edx)
77302829:	e9 db fc ff ff       	jmp    77302509 <_getICMPStats+0x259>
7730282e:	50                   	push   %eax
7730282f:	8d 85 d4 fd ff ff    	lea    0xfffffdd4(%ebp),%eax
77302835:	6a 0a                	push   $0xa
77302837:	50                   	push   %eax
77302838:	56                   	push   %esi
77302839:	e8 62 51 00 00       	call   773079a0 <_strtoul>
7730283e:	8b 55 08             	mov    0x8(%ebp),%edx
77302841:	8b b5 d4 fd ff ff    	mov    0xfffffdd4(%ebp),%esi
77302847:	83 c4 10             	add    $0x10,%esp
7730284a:	89 42 48             	mov    %eax,0x48(%edx)
7730284d:	e9 a6 fc ff ff       	jmp    773024f8 <_getICMPStats+0x248>
77302852:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
77302859:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77302860 <_getIPStats>:
77302860:	55                   	push   %ebp
77302861:	89 e5                	mov    %esp,%ebp
77302863:	83 7d 08 01          	cmpl   $0x1,0x8(%ebp)
77302867:	19 c0                	sbb    %eax,%eax
77302869:	5d                   	pop    %ebp
7730286a:	83 e0 57             	and    $0x57,%eax
7730286d:	c3                   	ret    
7730286e:	89 f6                	mov    %esi,%esi

77302870 <_getTCPStats>:
77302870:	55                   	push   %ebp
77302871:	89 e5                	mov    %esp,%ebp
77302873:	83 7d 08 01          	cmpl   $0x1,0x8(%ebp)
77302877:	19 c0                	sbb    %eax,%eax
77302879:	5d                   	pop    %ebp
7730287a:	83 e0 57             	and    $0x57,%eax
7730287d:	c3                   	ret    
7730287e:	89 f6                	mov    %esi,%esi

77302880 <_getUDPStats>:
77302880:	55                   	push   %ebp
77302881:	89 e5                	mov    %esp,%ebp
77302883:	83 7d 08 01          	cmpl   $0x1,0x8(%ebp)
77302887:	19 c0                	sbb    %eax,%eax
77302889:	5d                   	pop    %ebp
7730288a:	83 e0 57             	and    $0x57,%eax
7730288d:	c3                   	ret    
7730288e:	89 f6                	mov    %esi,%esi

77302890 <_getNumWithOneHeader>:
77302890:	55                   	push   %ebp
77302891:	31 c0                	xor    %eax,%eax
77302893:	89 e5                	mov    %esp,%ebp
77302895:	5d                   	pop    %ebp
77302896:	c3                   	ret    
77302897:	89 f6                	mov    %esi,%esi
77302899:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

773028a0 <_getNumRoutes>:
773028a0:	55                   	push   %ebp
773028a1:	89 e5                	mov    %esp,%ebp
773028a3:	57                   	push   %edi
773028a4:	56                   	push   %esi
773028a5:	53                   	push   %ebx
773028a6:	81 ec 88 00 00 00    	sub    $0x88,%esp
773028ac:	8d 45 84             	lea    0xffffff84(%ebp),%eax
773028af:	31 ff                	xor    %edi,%edi
773028b1:	50                   	push   %eax
773028b2:	e8 39 e9 ff ff       	call   773011f0 <_openTcpFile>
773028b7:	89 c3                	mov    %eax,%ebx
773028b9:	83 c4 10             	add    $0x10,%esp
773028bc:	31 c0                	xor    %eax,%eax
773028be:	85 db                	test   %ebx,%ebx
773028c0:	78 66                	js     77302928 <_getNumRoutes+0x88>
773028c2:	50                   	push   %eax
773028c3:	8d 45 80             	lea    0xffffff80(%ebp),%eax
773028c6:	50                   	push   %eax
773028c7:	8d 85 7c ff ff ff    	lea    0xffffff7c(%ebp),%eax
773028cd:	50                   	push   %eax
773028ce:	8b 45 84             	mov    0xffffff84(%ebp),%eax
773028d1:	50                   	push   %eax
773028d2:	e8 49 eb ff ff       	call   77301420 <_tdiGetEntityIDSet>
773028d7:	89 c3                	mov    %eax,%ebx
773028d9:	83 c4 10             	add    $0x10,%esp
773028dc:	31 c0                	xor    %eax,%eax
773028de:	85 db                	test   %ebx,%ebx
773028e0:	78 46                	js     77302928 <_getNumRoutes+0x88>
773028e2:	31 f6                	xor    %esi,%esi
773028e4:	3b 7d 80             	cmp    0xffffff80(%ebp),%edi
773028e7:	73 31                	jae    7730291a <_getNumRoutes+0x7a>
773028e9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
773028f0:	8d 1c f5 00 00 00 00 	lea    0x0(,%esi,8),%ebx
773028f7:	8b 95 7c ff ff ff    	mov    0xffffff7c(%ebp),%edx
773028fd:	89 d8                	mov    %ebx,%eax
773028ff:	01 d0                	add    %edx,%eax
77302901:	51                   	push   %ecx
77302902:	51                   	push   %ecx
77302903:	50                   	push   %eax
77302904:	8b 45 84             	mov    0xffffff84(%ebp),%eax
77302907:	50                   	push   %eax
77302908:	e8 63 f7 ff ff       	call   77302070 <_isIpEntity>
7730290d:	83 c4 10             	add    $0x10,%esp
77302910:	85 c0                	test   %eax,%eax
77302912:	75 1c                	jne    77302930 <_getNumRoutes+0x90>
77302914:	46                   	inc    %esi
77302915:	3b 75 80             	cmp    0xffffff80(%ebp),%esi
77302918:	72 d6                	jb     773028f0 <_getNumRoutes+0x50>
7730291a:	83 ec 0c             	sub    $0xc,%esp
7730291d:	8b 45 84             	mov    0xffffff84(%ebp),%eax
77302920:	50                   	push   %eax
77302921:	e8 3a e9 ff ff       	call   77301260 <_closeTcpFile>
77302926:	89 f8                	mov    %edi,%eax
77302928:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
7730292b:	5b                   	pop    %ebx
7730292c:	5e                   	pop    %esi
7730292d:	5f                   	pop    %edi
7730292e:	5d                   	pop    %ebp
7730292f:	c3                   	ret    
77302930:	8d 45 88             	lea    0xffffff88(%ebp),%eax
77302933:	51                   	push   %ecx
77302934:	6a 5c                	push   $0x5c
77302936:	6a 00                	push   $0x0
77302938:	50                   	push   %eax
77302939:	e8 52 50 00 00       	call   77307990 <_memset>
7730293e:	83 c4 0c             	add    $0xc,%esp
77302941:	8d 45 88             	lea    0xffffff88(%ebp),%eax
77302944:	8b 95 7c ff ff ff    	mov    0xffffff7c(%ebp),%edx
7730294a:	50                   	push   %eax
7730294b:	89 d8                	mov    %ebx,%eax
7730294d:	01 d0                	add    %edx,%eax
7730294f:	50                   	push   %eax
77302950:	8b 45 84             	mov    0xffffff84(%ebp),%eax
77302953:	50                   	push   %eax
77302954:	e8 37 f8 ff ff       	call   77302190 <_tdiGetMibForIpEntity>
77302959:	83 c4 10             	add    $0x10,%esp
7730295c:	89 c3                	mov    %eax,%ebx
7730295e:	85 c0                	test   %eax,%eax
77302960:	78 0b                	js     7730296d <_getNumRoutes+0xcd>
77302962:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
77302965:	46                   	inc    %esi
77302966:	01 c7                	add    %eax,%edi
77302968:	3b 75 80             	cmp    0xffffff80(%ebp),%esi
7730296b:	eb ab                	jmp    77302918 <_getNumRoutes+0x78>
7730296d:	83 ec 0c             	sub    $0xc,%esp
77302970:	8b b5 7c ff ff ff    	mov    0xffffff7c(%ebp),%esi
77302976:	56                   	push   %esi
77302977:	e8 24 ea ff ff       	call   773013a0 <_tdiFreeThingSet>
7730297c:	89 d8                	mov    %ebx,%eax
7730297e:	eb a8                	jmp    77302928 <_getNumRoutes+0x88>

77302980 <_HexDump>:
77302980:	55                   	push   %ebp
77302981:	89 e5                	mov    %esp,%ebp
77302983:	57                   	push   %edi
77302984:	56                   	push   %esi
77302985:	53                   	push   %ebx
77302986:	83 ec 0c             	sub    $0xc,%esp
77302989:	31 db                	xor    %ebx,%ebx
7730298b:	8b 7d 08             	mov    0x8(%ebp),%edi
7730298e:	8b 75 0c             	mov    0xc(%ebp),%esi
77302991:	eb 3f                	jmp    773029d2 <_HexDump+0x52>
77302993:	f6 c3 0f             	test   $0xf,%bl
77302996:	75 1c                	jne    773029b4 <_HexDump+0x34>
77302998:	85 db                	test   %ebx,%ebx
7730299a:	75 58                	jne    773029f4 <_HexDump+0x74>
7730299c:	50                   	push   %eax
7730299d:	53                   	push   %ebx
7730299e:	68 b7 a0 30 77       	push   $0x7730a0b7
773029a3:	a1 74 e2 30 77       	mov    0x7730e274,%eax
773029a8:	83 c0 40             	add    $0x40,%eax
773029ab:	50                   	push   %eax
773029ac:	e8 bf 55 00 00       	call   77307f70 <_fprintf>
773029b1:	83 c4 10             	add    $0x10,%esp
773029b4:	50                   	push   %eax
773029b5:	31 c0                	xor    %eax,%eax
773029b7:	8a 04 3b             	mov    (%ebx,%edi,1),%al
773029ba:	43                   	inc    %ebx
773029bb:	50                   	push   %eax
773029bc:	68 bd a0 30 77       	push   $0x7730a0bd
773029c1:	a1 74 e2 30 77       	mov    0x7730e274,%eax
773029c6:	83 c0 40             	add    $0x40,%eax
773029c9:	50                   	push   %eax
773029ca:	e8 a1 55 00 00       	call   77307f70 <_fprintf>
773029cf:	83 c4 10             	add    $0x10,%esp
773029d2:	39 f3                	cmp    %esi,%ebx
773029d4:	72 bd                	jb     77302993 <_HexDump+0x13>
773029d6:	a1 74 e2 30 77       	mov    0x7730e274,%eax
773029db:	c7 45 08 0a 00 00 00 	movl   $0xa,0x8(%ebp)
773029e2:	83 c0 40             	add    $0x40,%eax
773029e5:	89 45 0c             	mov    %eax,0xc(%ebp)
773029e8:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773029eb:	5b                   	pop    %ebx
773029ec:	5e                   	pop    %esi
773029ed:	5f                   	pop    %edi
773029ee:	5d                   	pop    %ebp
773029ef:	e9 6c 55 00 00       	jmp    77307f60 <_fputc>
773029f4:	50                   	push   %eax
773029f5:	50                   	push   %eax
773029f6:	a1 74 e2 30 77       	mov    0x7730e274,%eax
773029fb:	83 c0 40             	add    $0x40,%eax
773029fe:	50                   	push   %eax
773029ff:	6a 0a                	push   $0xa
77302a01:	e8 5a 55 00 00       	call   77307f60 <_fputc>
77302a06:	83 c4 10             	add    $0x10,%esp
77302a09:	eb 91                	jmp    7730299c <_HexDump+0x1c>
77302a0b:	90                   	nop    
77302a0c:	8d 74 26 00          	lea    0x0(%esi),%esi

77302a10 <_getRouteTable>:
77302a10:	55                   	push   %ebp
77302a11:	89 e5                	mov    %esp,%ebp
77302a13:	57                   	push   %edi
77302a14:	56                   	push   %esi
77302a15:	53                   	push   %ebx
77302a16:	81 ec 9c 00 00 00    	sub    $0x9c,%esp
77302a1c:	e8 7f fe ff ff       	call   773028a0 <_getNumRoutes>
77302a21:	83 ec 0c             	sub    $0xc,%esp
77302a24:	c7 85 68 ff ff ff 00 	movl   $0x0,0xffffff68(%ebp)
77302a2b:	00 00 00 
77302a2e:	89 85 74 ff ff ff    	mov    %eax,0xffffff74(%ebp)
77302a34:	8d 45 84             	lea    0xffffff84(%ebp),%eax
77302a37:	50                   	push   %eax
77302a38:	e8 b3 e7 ff ff       	call   773011f0 <_openTcpFile>
77302a3d:	83 c4 10             	add    $0x10,%esp
77302a40:	31 d2                	xor    %edx,%edx
77302a42:	85 c0                	test   %eax,%eax
77302a44:	0f 88 28 01 00 00    	js     77302b72 <_getRouteTable+0x162>
77302a4a:	53                   	push   %ebx
77302a4b:	8b 85 74 ff ff ff    	mov    0xffffff74(%ebp),%eax
77302a51:	8d 04 80             	lea    (%eax,%eax,4),%eax
77302a54:	8d 04 85 04 00 00 00 	lea    0x4(,%eax,4),%eax
77302a5b:	50                   	push   %eax
77302a5c:	6a 00                	push   $0x0
77302a5e:	51                   	push   %ecx
77302a5f:	e8 cc 29 00 00       	call   77305430 <_GetProcessHeap@0>
77302a64:	89 04 24             	mov    %eax,(%esp)
77302a67:	e8 d4 29 00 00       	call   77305440 <_HeapAlloc@12>
77302a6c:	c7 85 64 ff ff ff 00 	movl   $0x0,0xffffff64(%ebp)
77302a73:	00 00 00 
77302a76:	89 85 6c ff ff ff    	mov    %eax,0xffffff6c(%ebp)
77302a7c:	8b 85 74 ff ff ff    	mov    0xffffff74(%ebp),%eax
77302a82:	8b 95 6c ff ff ff    	mov    0xffffff6c(%ebp),%edx
77302a88:	39 85 68 ff ff ff    	cmp    %eax,0xffffff68(%ebp)
77302a8e:	89 02                	mov    %eax,(%edx)
77302a90:	5a                   	pop    %edx
77302a91:	0f 83 d5 00 00 00    	jae    77302b6c <_getRouteTable+0x15c>
77302a97:	8d bd 78 ff ff ff    	lea    0xffffff78(%ebp),%edi
77302a9d:	8d 76 00             	lea    0x0(%esi),%esi
77302aa0:	50                   	push   %eax
77302aa1:	8d 85 78 ff ff ff    	lea    0xffffff78(%ebp),%eax
77302aa7:	50                   	push   %eax
77302aa8:	8b 85 64 ff ff ff    	mov    0xffffff64(%ebp),%eax
77302aae:	50                   	push   %eax
77302aaf:	8b 75 84             	mov    0xffffff84(%ebp),%esi
77302ab2:	56                   	push   %esi
77302ab3:	e8 28 f6 ff ff       	call   773020e0 <_getNthIpEntity>
77302ab8:	83 c4 0c             	add    $0xc,%esp
77302abb:	8d 55 88             	lea    0xffffff88(%ebp),%edx
77302abe:	52                   	push   %edx
77302abf:	57                   	push   %edi
77302ac0:	8b 5d 84             	mov    0xffffff84(%ebp),%ebx
77302ac3:	53                   	push   %ebx
77302ac4:	e8 c7 f6 ff ff       	call   77302190 <_tdiGetMibForIpEntity>
77302ac9:	8d 85 74 ff ff ff    	lea    0xffffff74(%ebp),%eax
77302acf:	8d 95 70 ff ff ff    	lea    0xffffff70(%ebp),%edx
77302ad5:	50                   	push   %eax
77302ad6:	52                   	push   %edx
77302ad7:	57                   	push   %edi
77302ad8:	8b 4d 84             	mov    0xffffff84(%ebp),%ecx
77302adb:	51                   	push   %ecx
77302adc:	e8 1f f7 ff ff       	call   77302200 <_tdiGetRoutesForIpEntity>
77302ae1:	8b b5 70 ff ff ff    	mov    0xffffff70(%ebp),%esi
77302ae7:	83 c4 20             	add    $0x20,%esp
77302aea:	85 f6                	test   %esi,%esi
77302aec:	0f 84 9b 00 00 00    	je     77302b8d <_getRouteTable+0x17d>
77302af2:	31 db                	xor    %ebx,%ebx
77302af4:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
77302af7:	39 c3                	cmp    %eax,%ebx
77302af9:	73 40                	jae    77302b3b <_getRouteTable+0x12b>
77302afb:	8b 95 68 ff ff ff    	mov    0xffffff68(%ebp),%edx
77302b01:	8d 04 92             	lea    (%edx,%edx,4),%eax
77302b04:	8b 95 6c ff ff ff    	mov    0xffffff6c(%ebp),%edx
77302b0a:	8d 0c 82             	lea    (%edx,%eax,4),%ecx
77302b0d:	89 f2                	mov    %esi,%edx
77302b0f:	90                   	nop    
77302b10:	8b 02                	mov    (%edx),%eax
77302b12:	43                   	inc    %ebx
77302b13:	89 41 04             	mov    %eax,0x4(%ecx)
77302b16:	8b 42 28             	mov    0x28(%edx),%eax
77302b19:	89 41 08             	mov    %eax,0x8(%ecx)
77302b1c:	8b 42 18             	mov    0x18(%edx),%eax
77302b1f:	89 41 0c             	mov    %eax,0xc(%ecx)
77302b22:	8b 42 04             	mov    0x4(%edx),%eax
77302b25:	89 41 10             	mov    %eax,0x10(%ecx)
77302b28:	8b 42 08             	mov    0x8(%edx),%eax
77302b2b:	83 c2 34             	add    $0x34,%edx
77302b2e:	89 41 14             	mov    %eax,0x14(%ecx)
77302b31:	83 c1 14             	add    $0x14,%ecx
77302b34:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
77302b37:	39 c3                	cmp    %eax,%ebx
77302b39:	72 d5                	jb     77302b10 <_getRouteTable+0x100>
77302b3b:	85 f6                	test   %esi,%esi
77302b3d:	75 3d                	jne    77302b7c <_getRouteTable+0x16c>
77302b3f:	8b 95 68 ff ff ff    	mov    0xffffff68(%ebp),%edx
77302b45:	01 c2                	add    %eax,%edx
77302b47:	8b 85 64 ff ff ff    	mov    0xffffff64(%ebp),%eax
77302b4d:	40                   	inc    %eax
77302b4e:	89 95 68 ff ff ff    	mov    %edx,0xffffff68(%ebp)
77302b54:	89 85 64 ff ff ff    	mov    %eax,0xffffff64(%ebp)
77302b5a:	8b 85 68 ff ff ff    	mov    0xffffff68(%ebp),%eax
77302b60:	3b 85 74 ff ff ff    	cmp    0xffffff74(%ebp),%eax
77302b66:	0f 82 34 ff ff ff    	jb     77302aa0 <_getRouteTable+0x90>
77302b6c:	8b 95 6c ff ff ff    	mov    0xffffff6c(%ebp),%edx
77302b72:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77302b75:	89 d0                	mov    %edx,%eax
77302b77:	5b                   	pop    %ebx
77302b78:	5e                   	pop    %esi
77302b79:	5f                   	pop    %edi
77302b7a:	5d                   	pop    %ebp
77302b7b:	c3                   	ret    
77302b7c:	83 ec 0c             	sub    $0xc,%esp
77302b7f:	56                   	push   %esi
77302b80:	e8 1b e8 ff ff       	call   773013a0 <_tdiFreeThingSet>
77302b85:	83 c4 10             	add    $0x10,%esp
77302b88:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
77302b8b:	eb b2                	jmp    77302b3f <_getRouteTable+0x12f>
77302b8d:	83 ec 0c             	sub    $0xc,%esp
77302b90:	8b 45 84             	mov    0xffffff84(%ebp),%eax
77302b93:	50                   	push   %eax
77302b94:	e8 c7 e6 ff ff       	call   77301260 <_closeTcpFile>
77302b99:	83 c4 0c             	add    $0xc,%esp
77302b9c:	8b bd 6c ff ff ff    	mov    0xffffff6c(%ebp),%edi
77302ba2:	57                   	push   %edi
77302ba3:	6a 00                	push   $0x0
77302ba5:	56                   	push   %esi
77302ba6:	e8 85 28 00 00       	call   77305430 <_GetProcessHeap@0>
77302bab:	89 04 24             	mov    %eax,(%esp)
77302bae:	e8 9d 28 00 00       	call   77305450 <_HeapFree@12>
77302bb3:	31 d2                	xor    %edx,%edx
77302bb5:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77302bb8:	89 d0                	mov    %edx,%eax
77302bba:	5b                   	pop    %ebx
77302bbb:	5e                   	pop    %esi
77302bbc:	5f                   	pop    %edi
77302bbd:	5d                   	pop    %ebp
77302bbe:	c3                   	ret    
77302bbf:	90                   	nop    

77302bc0 <_getNumArpEntries>:
77302bc0:	55                   	push   %ebp
77302bc1:	b8 c3 a0 30 77       	mov    $0x7730a0c3,%eax
77302bc6:	89 e5                	mov    %esp,%ebp
77302bc8:	5d                   	pop    %ebp
77302bc9:	e9 c2 fc ff ff       	jmp    77302890 <_getNumWithOneHeader>
77302bce:	89 f6                	mov    %esi,%esi

77302bd0 <_getArpTable>:
77302bd0:	55                   	push   %ebp
77302bd1:	31 c0                	xor    %eax,%eax
77302bd3:	89 e5                	mov    %esp,%ebp
77302bd5:	5d                   	pop    %ebp
77302bd6:	c3                   	ret    
77302bd7:	89 f6                	mov    %esi,%esi
77302bd9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77302be0 <_getNumUdpEntries>:
77302be0:	55                   	push   %ebp
77302be1:	b8 d1 a0 30 77       	mov    $0x7730a0d1,%eax
77302be6:	89 e5                	mov    %esp,%ebp
77302be8:	5d                   	pop    %ebp
77302be9:	e9 a2 fc ff ff       	jmp    77302890 <_getNumWithOneHeader>
77302bee:	89 f6                	mov    %esi,%esi

77302bf0 <_getUdpTable>:
77302bf0:	55                   	push   %ebp
77302bf1:	89 e5                	mov    %esp,%ebp
77302bf3:	57                   	push   %edi
77302bf4:	56                   	push   %esi
77302bf5:	53                   	push   %ebx
77302bf6:	81 ec 1c 02 00 00    	sub    $0x21c,%esp
77302bfc:	e8 df ff ff ff       	call   77302be0 <_getNumUdpEntries>
77302c01:	89 85 e0 fd ff ff    	mov    %eax,0xfffffde0(%ebp)
77302c07:	8d 04 c5 04 00 00 00 	lea    0x4(,%eax,8),%eax
77302c0e:	52                   	push   %edx
77302c0f:	52                   	push   %edx
77302c10:	50                   	push   %eax
77302c11:	6a 01                	push   $0x1
77302c13:	e8 38 53 00 00       	call   77307f50 <_calloc>
77302c18:	83 c4 10             	add    $0x10,%esp
77302c1b:	89 c6                	mov    %eax,%esi
77302c1d:	85 c0                	test   %eax,%eax
77302c1f:	0f 84 a9 00 00 00    	je     77302cce <_getUdpTable+0xde>
77302c25:	50                   	push   %eax
77302c26:	50                   	push   %eax
77302c27:	68 a0 a0 30 77       	push   $0x7730a0a0
77302c2c:	68 d1 a0 30 77       	push   $0x7730a0d1
77302c31:	e8 6a 53 00 00       	call   77307fa0 <_fopen>
77302c36:	83 c4 10             	add    $0x10,%esp
77302c39:	89 c7                	mov    %eax,%edi
77302c3b:	85 c0                	test   %eax,%eax
77302c3d:	0f 84 8b 00 00 00    	je     77302cce <_getUdpTable+0xde>
77302c43:	50                   	push   %eax
77302c44:	8d 85 e8 fd ff ff    	lea    0xfffffde8(%ebp),%eax
77302c4a:	68 00 02 00 00       	push   $0x200
77302c4f:	6a 00                	push   $0x0
77302c51:	50                   	push   %eax
77302c52:	e8 39 4d 00 00       	call   77307990 <_memset>
77302c57:	83 c4 0c             	add    $0xc,%esp
77302c5a:	8d 95 e8 fd ff ff    	lea    0xfffffde8(%ebp),%edx
77302c60:	57                   	push   %edi
77302c61:	68 00 02 00 00       	push   $0x200
77302c66:	52                   	push   %edx
77302c67:	e8 24 53 00 00       	call   77307f90 <_fgets>
77302c6c:	83 c4 10             	add    $0x10,%esp
77302c6f:	85 c0                	test   %eax,%eax
77302c71:	74 4f                	je     77302cc2 <_getUdpTable+0xd2>
77302c73:	8b 85 e0 fd ff ff    	mov    0xfffffde0(%ebp),%eax
77302c79:	39 06                	cmp    %eax,(%esi)
77302c7b:	73 45                	jae    77302cc2 <_getUdpTable+0xd2>
77302c7d:	8d 76 00             	lea    0x0(%esi),%esi
77302c80:	8d 95 e8 fd ff ff    	lea    0xfffffde8(%ebp),%edx
77302c86:	50                   	push   %eax
77302c87:	57                   	push   %edi
77302c88:	68 00 02 00 00       	push   $0x200
77302c8d:	52                   	push   %edx
77302c8e:	e8 fd 52 00 00       	call   77307f90 <_fgets>
77302c93:	83 c4 10             	add    $0x10,%esp
77302c96:	85 c0                	test   %eax,%eax
77302c98:	74 28                	je     77302cc2 <_getUdpTable+0xd2>
77302c9a:	80 38 00             	cmpb   $0x0,(%eax)
77302c9d:	75 39                	jne    77302cd8 <_getUdpTable+0xe8>
77302c9f:	85 c0                	test   %eax,%eax
77302ca1:	74 0e                	je     77302cb1 <_getUdpTable+0xc1>
77302ca3:	80 38 00             	cmpb   $0x0,(%eax)
77302ca6:	75 4b                	jne    77302cf3 <_getUdpTable+0x103>
77302ca8:	85 c0                	test   %eax,%eax
77302caa:	74 05                	je     77302cb1 <_getUdpTable+0xc1>
77302cac:	80 38 00             	cmpb   $0x0,(%eax)
77302caf:	75 64                	jne    77302d15 <_getUdpTable+0x125>
77302cb1:	8b 16                	mov    (%esi),%edx
77302cb3:	42                   	inc    %edx
77302cb4:	85 c0                	test   %eax,%eax
77302cb6:	89 16                	mov    %edx,(%esi)
77302cb8:	74 08                	je     77302cc2 <_getUdpTable+0xd2>
77302cba:	3b 95 e0 fd ff ff    	cmp    0xfffffde0(%ebp),%edx
77302cc0:	72 be                	jb     77302c80 <_getUdpTable+0x90>
77302cc2:	83 ec 0c             	sub    $0xc,%esp
77302cc5:	57                   	push   %edi
77302cc6:	e8 b5 52 00 00       	call   77307f80 <_fclose>
77302ccb:	83 c4 10             	add    $0x10,%esp
77302cce:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77302cd1:	89 f0                	mov    %esi,%eax
77302cd3:	5b                   	pop    %ebx
77302cd4:	5e                   	pop    %esi
77302cd5:	5f                   	pop    %edi
77302cd6:	5d                   	pop    %ebp
77302cd7:	c3                   	ret    
77302cd8:	8d 95 e4 fd ff ff    	lea    0xfffffde4(%ebp),%edx
77302cde:	53                   	push   %ebx
77302cdf:	6a 10                	push   $0x10
77302ce1:	52                   	push   %edx
77302ce2:	50                   	push   %eax
77302ce3:	e8 b8 4c 00 00       	call   773079a0 <_strtoul>
77302ce8:	8b 85 e4 fd ff ff    	mov    0xfffffde4(%ebp),%eax
77302cee:	83 c4 10             	add    $0x10,%esp
77302cf1:	eb ac                	jmp    77302c9f <_getUdpTable+0xaf>
77302cf3:	40                   	inc    %eax
77302cf4:	8d 95 e4 fd ff ff    	lea    0xfffffde4(%ebp),%edx
77302cfa:	8b 1e                	mov    (%esi),%ebx
77302cfc:	51                   	push   %ecx
77302cfd:	6a 10                	push   $0x10
77302cff:	52                   	push   %edx
77302d00:	50                   	push   %eax
77302d01:	e8 9a 4c 00 00       	call   773079a0 <_strtoul>
77302d06:	83 c4 10             	add    $0x10,%esp
77302d09:	89 44 de 04          	mov    %eax,0x4(%esi,%ebx,8)
77302d0d:	8b 85 e4 fd ff ff    	mov    0xfffffde4(%ebp),%eax
77302d13:	eb 93                	jmp    77302ca8 <_getUdpTable+0xb8>
77302d15:	40                   	inc    %eax
77302d16:	52                   	push   %edx
77302d17:	8d 95 e4 fd ff ff    	lea    0xfffffde4(%ebp),%edx
77302d1d:	6a 10                	push   $0x10
77302d1f:	8b 1e                	mov    (%esi),%ebx
77302d21:	52                   	push   %edx
77302d22:	50                   	push   %eax
77302d23:	e8 78 4c 00 00       	call   773079a0 <_strtoul>
77302d28:	83 c4 10             	add    $0x10,%esp
77302d2b:	89 44 de 08          	mov    %eax,0x8(%esi,%ebx,8)
77302d2f:	8b 85 e4 fd ff ff    	mov    0xfffffde4(%ebp),%eax
77302d35:	e9 77 ff ff ff       	jmp    77302cb1 <_getUdpTable+0xc1>
77302d3a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

77302d40 <_getNumTcpEntries>:
77302d40:	55                   	push   %ebp
77302d41:	b8 df a0 30 77       	mov    $0x7730a0df,%eax
77302d46:	89 e5                	mov    %esp,%ebp
77302d48:	5d                   	pop    %ebp
77302d49:	e9 42 fb ff ff       	jmp    77302890 <_getNumWithOneHeader>
77302d4e:	89 f6                	mov    %esi,%esi

77302d50 <_getTcpTable>:
77302d50:	55                   	push   %ebp
77302d51:	31 c0                	xor    %eax,%eax
77302d53:	89 e5                	mov    %esp,%ebp
77302d55:	5d                   	pop    %ebp
77302d56:	c3                   	ret    
77302d57:	90                   	nop    
77302d58:	90                   	nop    
77302d59:	90                   	nop    
77302d5a:	90                   	nop    
77302d5b:	90                   	nop    
77302d5c:	90                   	nop    
77302d5d:	90                   	nop    
77302d5e:	90                   	nop    
77302d5f:	90                   	nop    

77302d60 <_DllMain@12>:

WINE_DEFAULT_DEBUG_CHANNEL(iphlpapi);

BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
77302d60:	55                   	push   %ebp
77302d61:	89 e5                	mov    %esp,%ebp
77302d63:	52                   	push   %edx
77302d64:	52                   	push   %edx
77302d65:	8b 45 0c             	mov    0xc(%ebp),%eax
  switch (fdwReason) {
77302d68:	85 c0                	test   %eax,%eax
77302d6a:	74 0c                	je     77302d78 <_DllMain@12+0x18>
77302d6c:	48                   	dec    %eax
77302d6d:	74 17                	je     77302d86 <_DllMain@12+0x26>
    case DLL_PROCESS_ATTACH:
      DisableThreadLibraryCalls( hinstDLL );
      interfaceMapInit();
      break;

    case DLL_PROCESS_DETACH:
      interfaceMapFree();
      break;
  }
  return TRUE;
}
77302d6f:	b8 01 00 00 00       	mov    $0x1,%eax
77302d74:	c9                   	leave  
77302d75:	c2 0c 00             	ret    $0xc
77302d78:	e8 63 e4 ff ff       	call   773011e0 <_interfaceMapFree>
77302d7d:	b8 01 00 00 00       	mov    $0x1,%eax
77302d82:	c9                   	leave  
77302d83:	c2 0c 00             	ret    $0xc
77302d86:	83 ec 0c             	sub    $0xc,%esp
77302d89:	8b 45 08             	mov    0x8(%ebp),%eax
77302d8c:	50                   	push   %eax
77302d8d:	e8 ce 26 00 00       	call   77305460 <_DisableThreadLibraryCalls@4>
77302d92:	83 c4 0c             	add    $0xc,%esp
77302d95:	e8 36 e4 ff ff       	call   773011d0 <_interfaceMapInit>
77302d9a:	b8 01 00 00 00       	mov    $0x1,%eax
77302d9f:	c9                   	leave  
77302da0:	c2 0c 00             	ret    $0xc
77302da3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77302da9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77302db0 <_AddIPAddress@20>:

/******************************************************************
 *    AddIPAddress (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  Address [In]
 *  IpMask [In]
 *  IfIndex [In]
 *  NTEContext [In/Out]
 *  NTEInstance [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI AddIPAddress(IPAddr Address, IPMask IpMask, DWORD IfIndex, PULONG NTEContext, PULONG NTEInstance)
{
77302db0:	55                   	push   %ebp
77302db1:	89 e5                	mov    %esp,%ebp
77302db3:	51                   	push   %ecx
77302db4:	51                   	push   %ecx
  FIXME(":stub\n");
77302db5:	68 f0 a0 30 77       	push   $0x7730a0f0
77302dba:	6a 57                	push   $0x57
77302dbc:	68 fd a0 30 77       	push   $0x7730a0fd
77302dc1:	68 0d a1 30 77       	push   $0x7730a10d
77302dc6:	e8 b5 4b 00 00       	call   77307980 <_DbgPrint>
77302dcb:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77302dd2:	e8 a9 4b 00 00       	call   77307980 <_DbgPrint>
  /* marking Win2K+ functions not supported */
  return ERROR_NOT_SUPPORTED;
}
77302dd7:	b8 32 00 00 00       	mov    $0x32,%eax
77302ddc:	c9                   	leave  
77302ddd:	c2 14 00             	ret    $0x14

77302de0 <_CreateIpForwardEntry@4>:


/******************************************************************
 *    AllocateAndGetIfTableFromStack (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  ppIfTable [Out] -- pointer into which the MIB_IFTABLE is
 *   allocated and returned.
 *  bOrder [In] -- passed to GetIfTable to order the table
 *  heap [In] -- heap from which the table is allocated
 *  flags [In] -- flags to HeapAlloc
 *
 * RETURNS -- ERROR_INVALID_PARAMETER if ppIfTable is NULL, whatever
 *  GetIfTable returns otherwise
 *
 */
DWORD WINAPI AllocateAndGetIfTableFromStack(PMIB_IFTABLE *ppIfTable,
 BOOL bOrder, HANDLE heap, DWORD flags)
{
  DWORD ret;

  TRACE("ppIfTable %p, bOrder %ld, heap 0x%08lx, flags 0x%08lx\n", ppIfTable,
   (DWORD)bOrder, (DWORD)heap, flags);
  if (!ppIfTable)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD dwSize = 0;

    ret = GetIfTable(*ppIfTable, &dwSize, bOrder);
    if (ret == ERROR_INSUFFICIENT_BUFFER) {
      *ppIfTable = (PMIB_IFTABLE)HeapAlloc(heap, flags, dwSize);
      ret = GetIfTable(*ppIfTable, &dwSize, bOrder);
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}


/******************************************************************
 *    AllocateAndGetIpAddrTableFromStack (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  ppIpAddrTable [Out]
 *  bOrder [In] -- passed to GetIpAddrTable to order the table
 *  heap [In] -- heap from which the table is allocated
 *  flags [In] -- flags to HeapAlloc
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI AllocateAndGetIpAddrTableFromStack(PMIB_IPADDRTABLE *ppIpAddrTable,
 BOOL bOrder, HANDLE heap, DWORD flags)
{
  DWORD ret;

  TRACE("ppIpAddrTable %p, bOrder %ld, heap 0x%08lx, flags 0x%08lx\n",
   ppIpAddrTable, (DWORD)bOrder, (DWORD)heap, flags);
  if (!ppIpAddrTable)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD dwSize = 0;

    ret = GetIpAddrTable(*ppIpAddrTable, &dwSize, bOrder);
    if (ret == ERROR_INSUFFICIENT_BUFFER) {
      *ppIpAddrTable = (PMIB_IPADDRTABLE)HeapAlloc(heap, flags, dwSize);
      ret = GetIpAddrTable(*ppIpAddrTable, &dwSize, bOrder);
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}


/******************************************************************
 *    AllocateAndGetIpForwardTableFromStack (IPHLPAPI.@)
 *
 *
 *  ppIpForwardTable [Out] -- pointer into which the MIB_IPFORWARDTABLE is
 *   allocated and returned.
 *  bOrder [In] -- passed to GetIfTable to order the table
 *  heap [In] -- heap from which the table is allocated
 *  flags [In] -- flags to HeapAlloc
 *
 * RETURNS -- ERROR_INVALID_PARAMETER if ppIfTable is NULL, whatever
 *  GetIpForwardTable returns otherwise
 *
 */
DWORD WINAPI AllocateAndGetIpForwardTableFromStack(PMIB_IPFORWARDTABLE *
 ppIpForwardTable, BOOL bOrder, HANDLE heap, DWORD flags)
{
  DWORD ret;

  TRACE("ppIpForwardTable %p, bOrder %ld, heap 0x%08lx, flags 0x%08lx\n",
   ppIpForwardTable, (DWORD)bOrder, (DWORD)heap, flags);
  if (!ppIpForwardTable)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD dwSize = 0;

    ret = GetIpForwardTable(*ppIpForwardTable, &dwSize, bOrder);
    if (ret == ERROR_INSUFFICIENT_BUFFER) {
      *ppIpForwardTable = (PMIB_IPFORWARDTABLE)HeapAlloc(heap, flags, dwSize);
      ret = GetIpForwardTable(*ppIpForwardTable, &dwSize, bOrder);
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}


/******************************************************************
 *    AllocateAndGetIpNetTableFromStack (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  ppIpNetTable [Out]
 *  bOrder [In] -- passed to GetIpNetTable to order the table
 *  heap [In] -- heap from which the table is allocated
 *  flags [In] -- flags to HeapAlloc
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI AllocateAndGetIpNetTableFromStack(PMIB_IPNETTABLE *ppIpNetTable,
 BOOL bOrder, HANDLE heap, DWORD flags)
{
  DWORD ret;

  TRACE("ppIpNetTable %p, bOrder %ld, heap 0x%08lx, flags 0x%08lx\n",
   ppIpNetTable, (DWORD)bOrder, (DWORD)heap, flags);
  if (!ppIpNetTable)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD dwSize = 0;

    ret = GetIpNetTable(*ppIpNetTable, &dwSize, bOrder);
    if (ret == ERROR_INSUFFICIENT_BUFFER) {
      *ppIpNetTable = (PMIB_IPNETTABLE)HeapAlloc(heap, flags, dwSize);
      ret = GetIpNetTable(*ppIpNetTable, &dwSize, bOrder);
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}


/******************************************************************
 *    AllocateAndGetTcpTableFromStack (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  ppTcpTable [Out]
 *  bOrder [In] -- passed to GetTcpTable to order the table
 *  heap [In] -- heap from which the table is allocated
 *  flags [In] -- flags to HeapAlloc
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI AllocateAndGetTcpTableFromStack(PMIB_TCPTABLE *ppTcpTable,
 BOOL bOrder, HANDLE heap, DWORD flags)
{
  DWORD ret;

  TRACE("ppTcpTable %p, bOrder %ld, heap 0x%08lx, flags 0x%08lx\n",
   ppTcpTable, (DWORD)bOrder, (DWORD)heap, flags);
  if (!ppTcpTable)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD dwSize = 0;

    ret = GetTcpTable(*ppTcpTable, &dwSize, bOrder);
    if (ret == ERROR_INSUFFICIENT_BUFFER) {
      *ppTcpTable = (PMIB_TCPTABLE)HeapAlloc(heap, flags, dwSize);
      ret = GetTcpTable(*ppTcpTable, &dwSize, bOrder);
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}


/******************************************************************
 *    AllocateAndGetUdpTableFromStack (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  ppUdpTable [Out]
 *  bOrder [In] -- passed to GetUdpTable to order the table
 *  heap [In] -- heap from which the table is allocated
 *  flags [In] -- flags to HeapAlloc
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI AllocateAndGetUdpTableFromStack(PMIB_UDPTABLE *ppUdpTable,
 BOOL bOrder, HANDLE heap, DWORD flags)
{
  DWORD ret;

  TRACE("ppUdpTable %p, bOrder %ld, heap 0x%08lx, flags 0x%08lx\n",
   ppUdpTable, (DWORD)bOrder, (DWORD)heap, flags);
  if (!ppUdpTable)
    ret = ERROR_INVALID_PARAMETER;
  else {
    DWORD dwSize = 0;

    ret = GetUdpTable(*ppUdpTable, &dwSize, bOrder);
    if (ret == ERROR_INSUFFICIENT_BUFFER) {
      *ppUdpTable = (PMIB_UDPTABLE)HeapAlloc(heap, flags, dwSize);
      ret = GetUdpTable(*ppUdpTable, &dwSize, bOrder);
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}


/******************************************************************
 *    CreateIpForwardEntry (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pRoute [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI CreateIpForwardEntry(PMIB_IPFORWARDROW pRoute)
{
77302de0:	55                   	push   %ebp
77302de1:	89 e5                	mov    %esp,%ebp
77302de3:	83 ec 14             	sub    $0x14,%esp
    return createIpForwardEntry( pRoute );
77302de6:	8b 45 08             	mov    0x8(%ebp),%eax
77302de9:	50                   	push   %eax
77302dea:	e8 d1 1e 00 00       	call   77304cc0 <_createIpForwardEntry>
}
77302def:	c9                   	leave  
77302df0:	c2 04 00             	ret    $0x4
77302df3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77302df9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77302e00 <_CreateIpNetEntry@4>:


/******************************************************************
 *    CreateIpNetEntry (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pArpEntry [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI CreateIpNetEntry(PMIB_IPNETROW pArpEntry)
{
77302e00:	55                   	push   %ebp
77302e01:	89 e5                	mov    %esp,%ebp
77302e03:	50                   	push   %eax
77302e04:	50                   	push   %eax
  TRACE("pArpEntry %p\n", pArpEntry);
  /* could use SIOCSARP on systems that support it, not sure I want to */
  FIXME(":stub\n");
77302e05:	68 20 a1 30 77       	push   $0x7730a120
77302e0a:	68 69 01 00 00       	push   $0x169
77302e0f:	68 fd a0 30 77       	push   $0x7730a0fd
77302e14:	68 0d a1 30 77       	push   $0x7730a10d
77302e19:	e8 62 4b 00 00       	call   77307980 <_DbgPrint>
77302e1e:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77302e25:	e8 56 4b 00 00       	call   77307980 <_DbgPrint>
  return (DWORD) 0;
}
77302e2a:	31 c0                	xor    %eax,%eax
77302e2c:	c9                   	leave  
77302e2d:	c2 04 00             	ret    $0x4

77302e30 <_CreateProxyArpEntry@12>:


/******************************************************************
 *    CreateProxyArpEntry (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  dwAddress [In]
 *  dwMask [In]
 *  dwIfIndex [In]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI CreateProxyArpEntry(DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex)
{
77302e30:	55                   	push   %ebp
77302e31:	89 e5                	mov    %esp,%ebp
77302e33:	50                   	push   %eax
77302e34:	50                   	push   %eax
  TRACE("dwAddress 0x%08lx, dwMask 0x%08lx, dwIfIndex 0x%08lx\n", dwAddress,
   dwMask, dwIfIndex);
  FIXME(":stub\n");
77302e35:	68 31 a1 30 77       	push   $0x7730a131
77302e3a:	68 81 01 00 00       	push   $0x181
77302e3f:	68 fd a0 30 77       	push   $0x7730a0fd
77302e44:	68 0d a1 30 77       	push   $0x7730a10d
77302e49:	e8 32 4b 00 00       	call   77307980 <_DbgPrint>
77302e4e:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77302e55:	e8 26 4b 00 00       	call   77307980 <_DbgPrint>
  /* marking Win2K+ functions not supported */
  return ERROR_NOT_SUPPORTED;
}
77302e5a:	b8 32 00 00 00       	mov    $0x32,%eax
77302e5f:	c9                   	leave  
77302e60:	c2 0c 00             	ret    $0xc
77302e63:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77302e69:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77302e70 <_DeleteIPAddress@4>:


/******************************************************************
 *    DeleteIPAddress (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  NTEContext [In]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI DeleteIPAddress(ULONG NTEContext)
{
77302e70:	55                   	push   %ebp
77302e71:	89 e5                	mov    %esp,%ebp
77302e73:	50                   	push   %eax
77302e74:	50                   	push   %eax
  TRACE("NTEContext %ld\n", NTEContext);
  FIXME(":stub\n");
77302e75:	68 45 a1 30 77       	push   $0x7730a145
77302e7a:	68 97 01 00 00       	push   $0x197
77302e7f:	68 fd a0 30 77       	push   $0x7730a0fd
77302e84:	68 0d a1 30 77       	push   $0x7730a10d
77302e89:	e8 f2 4a 00 00       	call   77307980 <_DbgPrint>
77302e8e:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77302e95:	e8 e6 4a 00 00       	call   77307980 <_DbgPrint>
  /* marking Win2K+ functions not supported */
  return ERROR_NOT_SUPPORTED;
}
77302e9a:	b8 32 00 00 00       	mov    $0x32,%eax
77302e9f:	c9                   	leave  
77302ea0:	c2 04 00             	ret    $0x4
77302ea3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77302ea9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77302eb0 <_DeleteIpForwardEntry@4>:


/******************************************************************
 *    DeleteIpForwardEntry (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pRoute [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI DeleteIpForwardEntry(PMIB_IPFORWARDROW pRoute)
{
77302eb0:	55                   	push   %ebp
77302eb1:	89 e5                	mov    %esp,%ebp
77302eb3:	83 ec 14             	sub    $0x14,%esp
    return deleteIpForwardEntry( pRoute );
77302eb6:	8b 45 08             	mov    0x8(%ebp),%eax
77302eb9:	50                   	push   %eax
77302eba:	e8 51 1f 00 00       	call   77304e10 <_deleteIpForwardEntry>
}
77302ebf:	c9                   	leave  
77302ec0:	c2 04 00             	ret    $0x4
77302ec3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77302ec9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77302ed0 <_DeleteIpNetEntry@4>:


/******************************************************************
 *    DeleteIpNetEntry (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pArpEntry [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI DeleteIpNetEntry(PMIB_IPNETROW pArpEntry)
{
77302ed0:	55                   	push   %ebp
77302ed1:	89 e5                	mov    %esp,%ebp
77302ed3:	50                   	push   %eax
77302ed4:	50                   	push   %eax
  TRACE("pArpEntry %p\n", pArpEntry);
  /* could use SIOCDARP on systems that support it, not sure I want to */
  FIXME(":stub\n");
77302ed5:	68 55 a1 30 77       	push   $0x7730a155
77302eda:	68 c1 01 00 00       	push   $0x1c1
77302edf:	68 fd a0 30 77       	push   $0x7730a0fd
77302ee4:	68 0d a1 30 77       	push   $0x7730a10d
77302ee9:	e8 92 4a 00 00       	call   77307980 <_DbgPrint>
77302eee:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77302ef5:	e8 86 4a 00 00       	call   77307980 <_DbgPrint>
  return (DWORD) 0;
}
77302efa:	31 c0                	xor    %eax,%eax
77302efc:	c9                   	leave  
77302efd:	c2 04 00             	ret    $0x4

77302f00 <_DeleteProxyArpEntry@12>:


/******************************************************************
 *    DeleteProxyArpEntry (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  dwAddress [In]
 *  dwMask [In]
 *  dwIfIndex [In]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI DeleteProxyArpEntry(DWORD dwAddress, DWORD dwMask, DWORD dwIfIndex)
{
77302f00:	55                   	push   %ebp
77302f01:	89 e5                	mov    %esp,%ebp
77302f03:	52                   	push   %edx
77302f04:	52                   	push   %edx
  TRACE("dwAddress 0x%08lx, dwMask 0x%08lx, dwIfIndex 0x%08lx\n", dwAddress,
   dwMask, dwIfIndex);
  FIXME(":stub\n");
77302f05:	68 66 a1 30 77       	push   $0x7730a166
77302f0a:	68 d9 01 00 00       	push   $0x1d9
77302f0f:	68 fd a0 30 77       	push   $0x7730a0fd
77302f14:	68 0d a1 30 77       	push   $0x7730a10d
77302f19:	e8 62 4a 00 00       	call   77307980 <_DbgPrint>
77302f1e:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77302f25:	e8 56 4a 00 00       	call   77307980 <_DbgPrint>
  /* marking Win2K+ functions not supported */
  return ERROR_NOT_SUPPORTED;
}
77302f2a:	b8 32 00 00 00       	mov    $0x32,%eax
77302f2f:	c9                   	leave  
77302f30:	c2 0c 00             	ret    $0xc
77302f33:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77302f39:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77302f40 <_EnableRouter@8>:

/******************************************************************
 *    EnableRouter (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pHandle [In/Out]
 *  pOverlapped [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI EnableRouter(HANDLE * pHandle, OVERLAPPED * pOverlapped)
{
77302f40:	55                   	push   %ebp
77302f41:	89 e5                	mov    %esp,%ebp
77302f43:	51                   	push   %ecx
77302f44:	51                   	push   %ecx
  TRACE("pHandle %p, pOverlapped %p\n", pHandle, pOverlapped);
  FIXME(":stub\n");
77302f45:	68 7a a1 30 77       	push   $0x7730a17a
77302f4a:	68 ef 01 00 00       	push   $0x1ef
77302f4f:	68 fd a0 30 77       	push   $0x7730a0fd
77302f54:	68 0d a1 30 77       	push   $0x7730a10d
77302f59:	e8 22 4a 00 00       	call   77307980 <_DbgPrint>
77302f5e:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77302f65:	e8 16 4a 00 00       	call   77307980 <_DbgPrint>
  /* could echo "1" > /proc/net/sys/net/ipv4/ip_forward, not sure I want to
     could map EACCESS to ERROR_ACCESS_DENIED, I suppose
     marking Win2K+ functions not supported */
  return ERROR_NOT_SUPPORTED;
}
77302f6a:	b8 32 00 00 00       	mov    $0x32,%eax
77302f6f:	c9                   	leave  
77302f70:	c2 08 00             	ret    $0x8
77302f73:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77302f79:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77302f80 <_FlushIpNetTable@4>:


/******************************************************************
 *    FlushIpNetTable (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  dwIfIndex [In]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI FlushIpNetTable(DWORD dwIfIndex)
{
77302f80:	55                   	push   %ebp
77302f81:	89 e5                	mov    %esp,%ebp
77302f83:	50                   	push   %eax
77302f84:	50                   	push   %eax
  TRACE("dwIfIndex 0x%08lx\n", dwIfIndex);
  FIXME(":stub\n");
77302f85:	68 87 a1 30 77       	push   $0x7730a187
77302f8a:	68 07 02 00 00       	push   $0x207
77302f8f:	68 fd a0 30 77       	push   $0x7730a0fd
77302f94:	68 0d a1 30 77       	push   $0x7730a10d
77302f99:	e8 e2 49 00 00       	call   77307980 <_DbgPrint>
77302f9e:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77302fa5:	e8 d6 49 00 00       	call   77307980 <_DbgPrint>
  /* this flushes the arp cache of the given index
     marking Win2K+ functions not supported */
  return ERROR_NOT_SUPPORTED;
}
77302faa:	b8 32 00 00 00       	mov    $0x32,%eax
77302faf:	c9                   	leave  
77302fb0:	c2 04 00             	ret    $0x4
77302fb3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77302fb9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77302fc0 <_GetAdapterIndex@8>:


/******************************************************************
 *    GetAdapterIndex (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  AdapterName [In/Out]
 *  IfIndex [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetAdapterIndex(LPWSTR AdapterName, PULONG IfIndex)
{
77302fc0:	55                   	push   %ebp
77302fc1:	89 e5                	mov    %esp,%ebp
77302fc3:	50                   	push   %eax
77302fc4:	50                   	push   %eax
  TRACE("AdapterName %p, IfIndex %p\n", AdapterName, IfIndex);
  FIXME(":stub\n");
77302fc5:	68 97 a1 30 77       	push   $0x7730a197
77302fca:	68 1f 02 00 00       	push   $0x21f
77302fcf:	68 fd a0 30 77       	push   $0x7730a0fd
77302fd4:	68 0d a1 30 77       	push   $0x7730a10d
77302fd9:	e8 a2 49 00 00       	call   77307980 <_DbgPrint>
77302fde:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77302fe5:	e8 96 49 00 00       	call   77307980 <_DbgPrint>
  /* marking Win2K+ functions not supported */
  return ERROR_NOT_SUPPORTED;
}
77302fea:	b8 32 00 00 00       	mov    $0x32,%eax
77302fef:	c9                   	leave  
77302ff0:	c2 08 00             	ret    $0x8
77302ff3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77302ff9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77303000 <_GetAdaptersInfo@8>:


/******************************************************************
 *    GetAdaptersInfo (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pAdapterInfo [In/Out]
 *  pOutBufLen [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetAdaptersInfo(PIP_ADAPTER_INFO pAdapterInfo, PULONG pOutBufLen)
{
77303000:	55                   	push   %ebp
77303001:	89 e5                	mov    %esp,%ebp
77303003:	57                   	push   %edi
77303004:	56                   	push   %esi
77303005:	53                   	push   %ebx
77303006:	83 ec 4c             	sub    $0x4c,%esp
  DWORD ret;

  TRACE("pAdapterInfo %p, pOutBufLen %p\n", pAdapterInfo, pOutBufLen);
  if (!pOutBufLen)
    ret = ERROR_INVALID_PARAMETER;
77303009:	bb 57 00 00 00       	mov    $0x57,%ebx
7730300e:	8b 7d 0c             	mov    0xc(%ebp),%edi
77303011:	85 ff                	test   %edi,%edi
77303013:	74 23                	je     77303038 <_GetAdaptersInfo@8+0x38>
  else {
    DWORD numNonLoopbackInterfaces = getNumNonLoopbackInterfaces();
77303015:	e8 b6 e7 ff ff       	call   773017d0 <_getNumNonLoopbackInterfaces>

    if (numNonLoopbackInterfaces > 0) {
      /* this calculation assumes only one address in the IP_ADDR_STRING lists.
         that's okay, because:
         - we don't get multiple addresses per adapter anyway
         - we don't know about per-adapter gateways
         - DHCP and WINS servers can have max one entry per list */
      ULONG size = sizeof(IP_ADAPTER_INFO) * numNonLoopbackInterfaces;

      if (!pAdapterInfo || *pOutBufLen < size) {
        *pOutBufLen = size;
        ret = ERROR_BUFFER_OVERFLOW;
      }
      else {
        InterfaceIndexTable *table = getNonLoopbackInterfaceIndexTable();

        if (table) {
          size = sizeof(IP_ADAPTER_INFO) * table->numIndexes;
          if (*pOutBufLen < size) {
            *pOutBufLen = size;
            ret = ERROR_INSUFFICIENT_BUFFER;
          }
          else {
            DWORD ndx;
            HKEY hKey;
            BOOL winsEnabled = FALSE;
            IP_ADDRESS_STRING primaryWINS, secondaryWINS;

            memset(pAdapterInfo, 0, size);
            if (RegOpenKeyExA(HKEY_LOCAL_MACHINE,
             "Software\\Wine\\Wine\\Config\\Network", 0, KEY_READ,
             &hKey) == ERROR_SUCCESS) {
              DWORD size = sizeof(primaryWINS.String);
              unsigned long addr;

              RegQueryValueExA(hKey, "WinsServer", NULL, NULL,
               primaryWINS.String, &size);
              addr = inet_addr(primaryWINS.String);
              if (addr != INADDR_NONE && addr != INADDR_ANY)
                winsEnabled = TRUE;
              size = sizeof(secondaryWINS.String);
              RegQueryValueExA(hKey, "BackupWinsServer", NULL, NULL,
               secondaryWINS.String, &size);
              addr = inet_addr(secondaryWINS.String);
              if (addr != INADDR_NONE && addr != INADDR_ANY)
                winsEnabled = TRUE;
              RegCloseKey(hKey);
            }
            for (ndx = 0; ndx < table->numIndexes; ndx++) {
              PIP_ADAPTER_INFO ptr = &pAdapterInfo[ndx];
              DWORD addrLen = sizeof(ptr->Address), type;
              const char *ifname = 
                  getInterfaceNameByIndex(table->indexes[ndx]);

              /* on Win98 this is left empty, but whatever */
              
              strncpy(ptr->AdapterName,ifname,sizeof(ptr->AdapterName));
              consumeInterfaceName(ifname);
              ptr->AdapterName[MAX_ADAPTER_NAME_LENGTH] = '\0';
              getInterfacePhysicalByIndex(table->indexes[ndx], &addrLen,
               ptr->Address, &type);
              /* MS defines address length and type as UINT in some places and
                 DWORD in others, **sigh**.  Don't want to assume that PUINT and
                 PDWORD are equiv (64-bit?) */
              ptr->AddressLength = addrLen;
              ptr->Type = type;
              ptr->Index = table->indexes[ndx];
              toIPAddressString(getInterfaceIPAddrByIndex(table->indexes[ndx]),
               ptr->IpAddressList.IpAddress.String);
              toIPAddressString(getInterfaceMaskByIndex(table->indexes[ndx]),
               ptr->IpAddressList.IpMask.String);
              if (winsEnabled) {
                ptr->HaveWins = TRUE;
                memcpy(ptr->PrimaryWinsServer.IpAddress.String,
                 primaryWINS.String, sizeof(primaryWINS.String));
                memcpy(ptr->SecondaryWinsServer.IpAddress.String,
                 secondaryWINS.String, sizeof(secondaryWINS.String));
              }
              if (ndx < table->numIndexes - 1)
                ptr->Next = &pAdapterInfo[ndx + 1];
              else
                ptr->Next = NULL;
            }
            ret = NO_ERROR;
          }
          free(table);
        }
        else
          ret = ERROR_OUTOFMEMORY;
      }
    }
    else
      ret = ERROR_NO_DATA;
7730301a:	b3 e8                	mov    $0xe8,%bl
7730301c:	85 c0                	test   %eax,%eax
7730301e:	74 18                	je     77303038 <_GetAdaptersInfo@8+0x38>
77303020:	8d 04 80             	lea    (%eax,%eax,4),%eax
77303023:	8b 75 08             	mov    0x8(%ebp),%esi
77303026:	c1 e0 07             	shl    $0x7,%eax
77303029:	85 f6                	test   %esi,%esi
7730302b:	74 04                	je     77303031 <_GetAdaptersInfo@8+0x31>
7730302d:	39 07                	cmp    %eax,(%edi)
7730302f:	73 13                	jae    77303044 <_GetAdaptersInfo@8+0x44>
77303031:	89 07                	mov    %eax,(%edi)
77303033:	bb 6f 00 00 00       	mov    $0x6f,%ebx
  }
  TRACE("returning %ld\n", ret);
  return ret;
}
77303038:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
7730303b:	89 d8                	mov    %ebx,%eax
7730303d:	5b                   	pop    %ebx
7730303e:	5e                   	pop    %esi
7730303f:	5f                   	pop    %edi
77303040:	5d                   	pop    %ebp
77303041:	c2 08 00             	ret    $0x8
77303044:	e8 b7 eb ff ff       	call   77301c00 <_getNonLoopbackInterfaceIndexTable>
77303049:	bb 0e 00 00 00       	mov    $0xe,%ebx
7730304e:	85 c0                	test   %eax,%eax
77303050:	89 45 b4             	mov    %eax,0xffffffb4(%ebp)
77303053:	74 e3                	je     77303038 <_GetAdaptersInfo@8+0x38>
77303055:	8b 00                	mov    (%eax),%eax
77303057:	8d 0c 80             	lea    (%eax,%eax,4),%ecx
7730305a:	c1 e1 07             	shl    $0x7,%ecx
7730305d:	39 0f                	cmp    %ecx,(%edi)
7730305f:	0f 82 8b 01 00 00    	jb     773031f0 <_GetAdaptersInfo@8+0x1f0>
77303065:	fc                   	cld    
77303066:	31 c0                	xor    %eax,%eax
77303068:	8b 7d 08             	mov    0x8(%ebp),%edi
7730306b:	c1 e9 02             	shr    $0x2,%ecx
7730306e:	c7 45 b0 00 00 00 00 	movl   $0x0,0xffffffb0(%ebp)
77303075:	f3 ab                	repz stos %eax,%es:(%edi)
77303077:	83 ec 0c             	sub    $0xc,%esp
7730307a:	8d 45 c4             	lea    0xffffffc4(%ebp),%eax
7730307d:	50                   	push   %eax
7730307e:	68 19 00 02 00       	push   $0x20019
77303083:	6a 00                	push   $0x0
77303085:	68 a8 a1 30 77       	push   $0x7730a1a8
7730308a:	68 02 00 00 80       	push   $0x80000002
7730308f:	e8 1c 23 00 00       	call   773053b0 <_RegOpenKeyExA@20>
77303094:	83 c4 0c             	add    $0xc,%esp
77303097:	85 c0                	test   %eax,%eax
77303099:	0f 84 6d 01 00 00    	je     7730320c <_GetAdaptersInfo@8+0x20c>
7730309f:	8b 55 b4             	mov    0xffffffb4(%ebp),%edx
773030a2:	31 f6                	xor    %esi,%esi
773030a4:	8b 02                	mov    (%edx),%eax
773030a6:	85 c0                	test   %eax,%eax
773030a8:	0f 84 5a 01 00 00    	je     77303208 <_GetAdaptersInfo@8+0x208>
773030ae:	8b 7d 08             	mov    0x8(%ebp),%edi
773030b1:	eb 17                	jmp    773030ca <_GetAdaptersInfo@8+0xca>
773030b3:	8d 87 80 02 00 00    	lea    0x280(%edi),%eax
773030b9:	89 07                	mov    %eax,(%edi)
773030bb:	46                   	inc    %esi
773030bc:	81 c7 80 02 00 00    	add    $0x280,%edi
773030c2:	39 f2                	cmp    %esi,%edx
773030c4:	0f 86 3e 01 00 00    	jbe    77303208 <_GetAdaptersInfo@8+0x208>
773030ca:	8b 45 b4             	mov    0xffffffb4(%ebp),%eax
773030cd:	83 ec 0c             	sub    $0xc,%esp
773030d0:	c7 45 b8 08 00 00 00 	movl   $0x8,0xffffffb8(%ebp)
773030d7:	8b 44 b0 08          	mov    0x8(%eax,%esi,4),%eax
773030db:	50                   	push   %eax
773030dc:	e8 df e8 ff ff       	call   773019c0 <_getInterfaceNameByIndex>
773030e1:	83 c4 0c             	add    $0xc,%esp
773030e4:	89 c3                	mov    %eax,%ebx
773030e6:	68 04 01 00 00       	push   $0x104
773030eb:	50                   	push   %eax
773030ec:	8d 47 08             	lea    0x8(%edi),%eax
773030ef:	50                   	push   %eax
773030f0:	e8 4b 48 00 00       	call   77307940 <_strncpy>
773030f5:	89 1c 24             	mov    %ebx,(%esp)
773030f8:	e8 53 e9 ff ff       	call   77301a50 <_consumeInterfaceName>
773030fd:	c6 87 08 01 00 00 00 	movb   $0x0,0x108(%edi)
77303104:	8d 55 bc             	lea    0xffffffbc(%ebp),%edx
77303107:	8d 87 94 01 00 00    	lea    0x194(%edi),%eax
7730310d:	52                   	push   %edx
7730310e:	8b 55 b4             	mov    0xffffffb4(%ebp),%edx
77303111:	50                   	push   %eax
77303112:	8d 45 b8             	lea    0xffffffb8(%ebp),%eax
77303115:	50                   	push   %eax
77303116:	8b 5c b2 08          	mov    0x8(%edx,%esi,4),%ebx
7730311a:	53                   	push   %ebx
7730311b:	e8 20 ed ff ff       	call   77301e40 <_getInterfacePhysicalByIndex>
77303120:	8b 55 b4             	mov    0xffffffb4(%ebp),%edx
77303123:	8b 45 b8             	mov    0xffffffb8(%ebp),%eax
77303126:	89 87 90 01 00 00    	mov    %eax,0x190(%edi)
7730312c:	8b 45 bc             	mov    0xffffffbc(%ebp),%eax
7730312f:	83 c4 18             	add    $0x18,%esp
77303132:	89 87 a0 01 00 00    	mov    %eax,0x1a0(%edi)
77303138:	8b 44 b2 08          	mov    0x8(%edx,%esi,4),%eax
7730313c:	89 87 9c 01 00 00    	mov    %eax,0x19c(%edi)
77303142:	8d 87 b0 01 00 00    	lea    0x1b0(%edi),%eax
77303148:	50                   	push   %eax
77303149:	8b 4c b2 08          	mov    0x8(%edx,%esi,4),%ecx
7730314d:	51                   	push   %ecx
7730314e:	e8 9d eb ff ff       	call   77301cf0 <_getInterfaceIPAddrByIndex>
77303153:	89 04 24             	mov    %eax,(%esp)
77303156:	e8 e5 ee ff ff       	call   77302040 <_toIPAddressString>
7730315b:	58                   	pop    %eax
7730315c:	8d 87 c0 01 00 00    	lea    0x1c0(%edi),%eax
77303162:	5a                   	pop    %edx
77303163:	50                   	push   %eax
77303164:	8b 45 b4             	mov    0xffffffb4(%ebp),%eax
77303167:	8b 44 b0 08          	mov    0x8(%eax,%esi,4),%eax
7730316b:	50                   	push   %eax
7730316c:	e8 ff eb ff ff       	call   77301d70 <_getInterfaceMaskByIndex>
77303171:	89 04 24             	mov    %eax,(%esp)
77303174:	e8 c7 ee ff ff       	call   77302040 <_toIPAddressString>
77303179:	8b 45 b0             	mov    0xffffffb0(%ebp),%eax
7730317c:	83 c4 10             	add    $0x10,%esp
7730317f:	85 c0                	test   %eax,%eax
77303181:	74 52                	je     773031d5 <_GetAdaptersInfo@8+0x1d5>
77303183:	c7 87 24 02 00 00 01 	movl   $0x1,0x224(%edi)
7730318a:	00 00 00 
7730318d:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
77303190:	89 87 2c 02 00 00    	mov    %eax,0x22c(%edi)
77303196:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
77303199:	89 87 30 02 00 00    	mov    %eax,0x230(%edi)
7730319f:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
773031a2:	89 87 34 02 00 00    	mov    %eax,0x234(%edi)
773031a8:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
773031ab:	89 87 38 02 00 00    	mov    %eax,0x238(%edi)
773031b1:	8b 45 c8             	mov    0xffffffc8(%ebp),%eax
773031b4:	89 87 54 02 00 00    	mov    %eax,0x254(%edi)
773031ba:	8b 45 cc             	mov    0xffffffcc(%ebp),%eax
773031bd:	89 87 58 02 00 00    	mov    %eax,0x258(%edi)
773031c3:	8b 45 d0             	mov    0xffffffd0(%ebp),%eax
773031c6:	89 87 5c 02 00 00    	mov    %eax,0x25c(%edi)
773031cc:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
773031cf:	89 87 60 02 00 00    	mov    %eax,0x260(%edi)
773031d5:	8b 45 b4             	mov    0xffffffb4(%ebp),%eax
773031d8:	8b 10                	mov    (%eax),%edx
773031da:	8d 42 ff             	lea    0xffffffff(%edx),%eax
773031dd:	39 f0                	cmp    %esi,%eax
773031df:	0f 87 ce fe ff ff    	ja     773030b3 <_GetAdaptersInfo@8+0xb3>
773031e5:	c7 07 00 00 00 00    	movl   $0x0,(%edi)
773031eb:	e9 cb fe ff ff       	jmp    773030bb <_GetAdaptersInfo@8+0xbb>
773031f0:	89 0f                	mov    %ecx,(%edi)
773031f2:	b3 7a                	mov    $0x7a,%bl
773031f4:	83 ec 0c             	sub    $0xc,%esp
773031f7:	8b 45 b4             	mov    0xffffffb4(%ebp),%eax
773031fa:	50                   	push   %eax
773031fb:	e8 20 4d 00 00       	call   77307f20 <_free>
77303200:	83 c4 10             	add    $0x10,%esp
77303203:	e9 30 fe ff ff       	jmp    77303038 <_GetAdaptersInfo@8+0x38>
77303208:	31 db                	xor    %ebx,%ebx
7730320a:	eb e8                	jmp    773031f4 <_GetAdaptersInfo@8+0x1f4>
7730320c:	8b 4d c4             	mov    0xffffffc4(%ebp),%ecx
7730320f:	53                   	push   %ebx
77303210:	8d 75 c0             	lea    0xffffffc0(%ebp),%esi
77303213:	53                   	push   %ebx
77303214:	8d 5d d8             	lea    0xffffffd8(%ebp),%ebx
77303217:	56                   	push   %esi
77303218:	c7 45 c0 10 00 00 00 	movl   $0x10,0xffffffc0(%ebp)
7730321f:	53                   	push   %ebx
77303220:	6a 00                	push   $0x0
77303222:	6a 00                	push   $0x0
77303224:	68 ca a1 30 77       	push   $0x7730a1ca
77303229:	51                   	push   %ecx
7730322a:	e8 91 21 00 00       	call   773053c0 <_RegQueryValueExA@24>
7730322f:	52                   	push   %edx
77303230:	53                   	push   %ebx
77303231:	e8 ba 46 00 00       	call   773078f0 <_inet_addr@4>
77303236:	83 c4 0c             	add    $0xc,%esp
77303239:	83 f8 ff             	cmp    $0xffffffff,%eax
7730323c:	0f 95 c2             	setne  %dl
7730323f:	85 c0                	test   %eax,%eax
77303241:	0f 95 c0             	setne  %al
77303244:	25 ff 00 00 00       	and    $0xff,%eax
77303249:	85 c2                	test   %eax,%edx
7730324b:	74 07                	je     77303254 <_GetAdaptersInfo@8+0x254>
7730324d:	c7 45 b0 01 00 00 00 	movl   $0x1,0xffffffb0(%ebp)
77303254:	8d 5d c8             	lea    0xffffffc8(%ebp),%ebx
77303257:	50                   	push   %eax
77303258:	50                   	push   %eax
77303259:	8b 45 c4             	mov    0xffffffc4(%ebp),%eax
7730325c:	56                   	push   %esi
7730325d:	c7 45 c0 10 00 00 00 	movl   $0x10,0xffffffc0(%ebp)
77303264:	53                   	push   %ebx
77303265:	6a 00                	push   $0x0
77303267:	6a 00                	push   $0x0
77303269:	68 d5 a1 30 77       	push   $0x7730a1d5
7730326e:	50                   	push   %eax
7730326f:	e8 4c 21 00 00       	call   773053c0 <_RegQueryValueExA@24>
77303274:	50                   	push   %eax
77303275:	53                   	push   %ebx
77303276:	e8 75 46 00 00       	call   773078f0 <_inet_addr@4>
7730327b:	83 c4 0c             	add    $0xc,%esp
7730327e:	83 f8 ff             	cmp    $0xffffffff,%eax
77303281:	0f 95 c2             	setne  %dl
77303284:	85 c0                	test   %eax,%eax
77303286:	0f 95 c0             	setne  %al
77303289:	25 ff 00 00 00       	and    $0xff,%eax
7730328e:	85 c2                	test   %eax,%edx
77303290:	74 07                	je     77303299 <_GetAdaptersInfo@8+0x299>
77303292:	c7 45 b0 01 00 00 00 	movl   $0x1,0xffffffb0(%ebp)
77303299:	83 ec 0c             	sub    $0xc,%esp
7730329c:	8b 45 c4             	mov    0xffffffc4(%ebp),%eax
7730329f:	50                   	push   %eax
773032a0:	e8 2b 21 00 00       	call   773053d0 <_RegCloseKey@4>
773032a5:	83 c4 0c             	add    $0xc,%esp
773032a8:	e9 f2 fd ff ff       	jmp    7730309f <_GetAdaptersInfo@8+0x9f>
773032ad:	8d 76 00             	lea    0x0(%esi),%esi

773032b0 <_GetFriendlyIfIndex@4>:


/******************************************************************
 *    GetBestInterface (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  dwDestAddr [In]
 *  pdwBestIfIndex [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetBestInterface(IPAddr dwDestAddr, PDWORD pdwBestIfIndex)
{
  DWORD ret;

  TRACE("dwDestAddr 0x%08lx, pdwBestIfIndex %p\n", dwDestAddr, pdwBestIfIndex);
  if (!pdwBestIfIndex)
    ret = ERROR_INVALID_PARAMETER;
  else {
    MIB_IPFORWARDROW ipRow;

    ret = GetBestRoute(dwDestAddr, 0, &ipRow);
    if (ret == ERROR_SUCCESS)
      *pdwBestIfIndex = ipRow.dwForwardIfIndex;
  }
  TRACE("returning %ld\n", ret);
  return ret;
}


/******************************************************************
 *    GetBestRoute (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  dwDestAddr [In]
 *  dwSourceAddr [In]
 *  OUT [In]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetBestRoute(DWORD dwDestAddr, DWORD dwSourceAddr, PMIB_IPFORWARDROW pBestRoute)
{
  PMIB_IPFORWARDTABLE table;
  DWORD ret;

  TRACE("dwDestAddr 0x%08lx, dwSourceAddr 0x%08lx, pBestRoute %p\n", dwDestAddr,
   dwSourceAddr, pBestRoute);
  if (!pBestRoute)
    return ERROR_INVALID_PARAMETER;

  AllocateAndGetIpForwardTableFromStack(&table, FALSE, GetProcessHeap(), 0);
  if (table) {
    DWORD ndx, matchedBits, matchedNdx = 0;

    for (ndx = 0, matchedBits = 0; ndx < table->dwNumEntries; ndx++) {
      if ((dwDestAddr & table->table[ndx].dwForwardMask) ==
       (table->table[ndx].dwForwardDest & table->table[ndx].dwForwardMask)) {
        DWORD numShifts, mask;

        for (numShifts = 0, mask = table->table[ndx].dwForwardMask;
         mask && !(mask & 1); mask >>= 1, numShifts++)
          ;
        if (numShifts > matchedBits) {
          matchedBits = numShifts;
          matchedNdx = ndx;
        }
      }
    }
    memcpy(pBestRoute, &table->table[matchedNdx], sizeof(MIB_IPFORWARDROW));
    HeapFree(GetProcessHeap(), 0, table);
    ret = ERROR_SUCCESS;
  }
  else
    ret = ERROR_OUTOFMEMORY;
  TRACE("returning %ld\n", ret);
  return ret;
}


/******************************************************************
 *    GetFriendlyIfIndex (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  IfIndex [In]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetFriendlyIfIndex(DWORD IfIndex)
{
773032b0:	55                   	push   %ebp
773032b1:	89 e5                	mov    %esp,%ebp
773032b3:	8b 45 08             	mov    0x8(%ebp),%eax
  /* windows doesn't validate these, either, just makes sure the top byte is
     cleared.  I assume my ifenum module never gives an index with the top
     byte set. */
  TRACE("returning %ld\n", IfIndex);
  return IfIndex;
}
773032b6:	5d                   	pop    %ebp
773032b7:	c2 04 00             	ret    $0x4
773032ba:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

773032c0 <_GetIcmpStatistics@4>:


/******************************************************************
 *    GetIcmpStatistics (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pStats [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetIcmpStatistics(PMIB_ICMP pStats)
{
773032c0:	55                   	push   %ebp
773032c1:	89 e5                	mov    %esp,%ebp
773032c3:	83 ec 14             	sub    $0x14,%esp
  DWORD ret;

  TRACE("pStats %p\n", pStats);
  ret = getICMPStats(pStats);
773032c6:	8b 45 08             	mov    0x8(%ebp),%eax
773032c9:	50                   	push   %eax
773032ca:	e8 e1 ef ff ff       	call   773022b0 <_getICMPStats>
  TRACE("returning %ld\n", ret);
  return ret;
}
773032cf:	c9                   	leave  
773032d0:	c2 04 00             	ret    $0x4
773032d3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
773032d9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

773032e0 <_GetIfEntry@4>:


/******************************************************************
 *    GetIfEntry (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pIfRow [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetIfEntry(PMIB_IFROW pIfRow)
{
773032e0:	55                   	push   %ebp
  DWORD ret;
  const char *name;

  TRACE("pIfRow %p\n", pIfRow);
  if (!pIfRow)
    return ERROR_INVALID_PARAMETER;
773032e1:	b8 57 00 00 00       	mov    $0x57,%eax
773032e6:	89 e5                	mov    %esp,%ebp
773032e8:	57                   	push   %edi
773032e9:	56                   	push   %esi
773032ea:	53                   	push   %ebx
773032eb:	83 ec 0c             	sub    $0xc,%esp
773032ee:	8b 7d 08             	mov    0x8(%ebp),%edi
773032f1:	85 ff                	test   %edi,%edi
773032f3:	74 43                	je     77303338 <_GetIfEntry@4+0x58>

  name = getInterfaceNameByIndex(pIfRow->dwIndex);
773032f5:	83 ec 0c             	sub    $0xc,%esp
773032f8:	8b 87 00 02 00 00    	mov    0x200(%edi),%eax
  if (name) {
    ret = getInterfaceEntryByIndex(pIfRow->dwIndex, pIfRow);
    if (ret == NO_ERROR)
      ret = getInterfaceStatsByName(name, pIfRow);
    consumeInterfaceName(name);
  }
  else
    ret = ERROR_INVALID_DATA;
773032fe:	be 0d 00 00 00       	mov    $0xd,%esi
77303303:	50                   	push   %eax
77303304:	e8 b7 e6 ff ff       	call   773019c0 <_getInterfaceNameByIndex>
77303309:	83 c4 10             	add    $0x10,%esp
7730330c:	89 c3                	mov    %eax,%ebx
7730330e:	85 c0                	test   %eax,%eax
77303310:	74 24                	je     77303336 <_GetIfEntry@4+0x56>
77303312:	50                   	push   %eax
77303313:	50                   	push   %eax
77303314:	57                   	push   %edi
77303315:	8b 87 00 02 00 00    	mov    0x200(%edi),%eax
7730331b:	50                   	push   %eax
7730331c:	e8 9f ec ff ff       	call   77301fc0 <_getInterfaceEntryByIndex>
77303321:	83 c4 10             	add    $0x10,%esp
77303324:	89 c6                	mov    %eax,%esi
77303326:	85 c0                	test   %eax,%eax
77303328:	74 18                	je     77303342 <_GetIfEntry@4+0x62>
7730332a:	83 ec 0c             	sub    $0xc,%esp
7730332d:	53                   	push   %ebx
7730332e:	e8 1d e7 ff ff       	call   77301a50 <_consumeInterfaceName>
77303333:	83 c4 10             	add    $0x10,%esp
  TRACE("returning %ld\n", ret);
  return ret;
77303336:	89 f0                	mov    %esi,%eax
}
77303338:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
7730333b:	5b                   	pop    %ebx
7730333c:	5e                   	pop    %esi
7730333d:	5f                   	pop    %edi
7730333e:	5d                   	pop    %ebp
7730333f:	c2 04 00             	ret    $0x4
77303342:	50                   	push   %eax
77303343:	50                   	push   %eax
77303344:	57                   	push   %edi
77303345:	53                   	push   %ebx
77303346:	e8 35 ef ff ff       	call   77302280 <_getInterfaceStatsByName>
7730334b:	83 c4 10             	add    $0x10,%esp
7730334e:	89 c6                	mov    %eax,%esi
77303350:	83 ec 0c             	sub    $0xc,%esp
77303353:	53                   	push   %ebx
77303354:	e8 f7 e6 ff ff       	call   77301a50 <_consumeInterfaceName>
77303359:	83 c4 10             	add    $0x10,%esp
7730335c:	eb d8                	jmp    77303336 <_GetIfEntry@4+0x56>
7730335e:	89 f6                	mov    %esi,%esi

77303360 <_IfTableSorter>:


static int IfTableSorter(const void *a, const void *b)
{
77303360:	55                   	push   %ebp
77303361:	89 e5                	mov    %esp,%ebp
77303363:	56                   	push   %esi
77303364:	53                   	push   %ebx
77303365:	8b 75 0c             	mov    0xc(%ebp),%esi
77303368:	8b 5d 08             	mov    0x8(%ebp),%ebx
  int ret;

  if (a && b)
7730336b:	85 db                	test   %ebx,%ebx
7730336d:	0f 95 c2             	setne  %dl
77303370:	85 f6                	test   %esi,%esi
77303372:	0f 95 c0             	setne  %al
77303375:	25 ff 00 00 00       	and    $0xff,%eax
    ret = ((PMIB_IFROW)a)->dwIndex - ((PMIB_IFROW)b)->dwIndex;
  else
    ret = 0;
7730337a:	31 c9                	xor    %ecx,%ecx
7730337c:	85 c2                	test   %eax,%edx
7730337e:	74 0e                	je     7730338e <_IfTableSorter+0x2e>
77303380:	8b 8b 00 02 00 00    	mov    0x200(%ebx),%ecx
77303386:	8b 86 00 02 00 00    	mov    0x200(%esi),%eax
7730338c:	29 c1                	sub    %eax,%ecx
  return ret;
}
7730338e:	89 c8                	mov    %ecx,%eax
77303390:	5b                   	pop    %ebx
77303391:	5e                   	pop    %esi
77303392:	5d                   	pop    %ebp
77303393:	c3                   	ret    
77303394:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
7730339a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

773033a0 <_GetIfTable@12>:


/******************************************************************
 *    GetIfTable (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pIfTable [In/Out]
 *  pdwSize [In/Out]
 *  bOrder [In]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetIfTable(PMIB_IFTABLE pIfTable, PULONG pdwSize, BOOL bOrder)
{
773033a0:	55                   	push   %ebp
773033a1:	89 e5                	mov    %esp,%ebp
773033a3:	57                   	push   %edi
773033a4:	56                   	push   %esi
773033a5:	53                   	push   %ebx
773033a6:	83 ec 0c             	sub    $0xc,%esp
  DWORD ret;

  TRACE("pIfTable %p, pdwSize %p, bOrder %ld\n", pdwSize, pdwSize,
   (DWORD)bOrder);
  if (!pdwSize)
    ret = ERROR_INVALID_PARAMETER;
773033a9:	bb 57 00 00 00       	mov    $0x57,%ebx
773033ae:	8b 75 0c             	mov    0xc(%ebp),%esi
773033b1:	8b 7d 08             	mov    0x8(%ebp),%edi
773033b4:	85 f6                	test   %esi,%esi
773033b6:	74 26                	je     773033de <_GetIfTable@12+0x3e>
  else {
    DWORD numInterfaces = getNumInterfaces();
773033b8:	e8 03 e4 ff ff       	call   773017c0 <_getNumInterfaces>
    TRACE("GetIfTable: numInterfaces = %d\n", (int)numInterfaces);
    ULONG size = sizeof(MIB_IFTABLE) + (numInterfaces - 1) * sizeof(MIB_IFROW);
773033bd:	8d 14 40             	lea    (%eax,%eax,2),%edx
773033c0:	8d 14 d2             	lea    (%edx,%edx,8),%edx
773033c3:	c1 e2 03             	shl    $0x3,%edx
773033c6:	29 c2                	sub    %eax,%edx

    if (!pIfTable || *pdwSize < size) {
773033c8:	85 ff                	test   %edi,%edi
773033ca:	8d 04 95 04 00 00 00 	lea    0x4(,%edx,4),%eax
773033d1:	74 04                	je     773033d7 <_GetIfTable@12+0x37>
773033d3:	39 06                	cmp    %eax,(%esi)
773033d5:	73 19                	jae    773033f0 <_GetIfTable@12+0x50>
      *pdwSize = size;
773033d7:	89 06                	mov    %eax,(%esi)
      ret = ERROR_INSUFFICIENT_BUFFER;
773033d9:	bb 7a 00 00 00       	mov    $0x7a,%ebx
    }
    else {
      InterfaceIndexTable *table = getInterfaceIndexTable();

      if (table) {
        size = sizeof(MIB_IFTABLE) + (table->numIndexes - 1) *
         sizeof(MIB_IFROW);
        if (*pdwSize < size) {
          *pdwSize = size;
          ret = ERROR_INSUFFICIENT_BUFFER;
        }
        else {
          DWORD ndx;

          pIfTable->dwNumEntries = 0;
          for (ndx = 0; ndx < table->numIndexes; ndx++) {
            pIfTable->table[ndx].dwIndex = table->indexes[ndx];
            GetIfEntry(&pIfTable->table[ndx]);
            pIfTable->dwNumEntries++;
          }
          if (bOrder)
            qsort(pIfTable->table, pIfTable->dwNumEntries, sizeof(MIB_IFROW),
             IfTableSorter);
          ret = NO_ERROR;
        }
        free(table);
      }
      else
        ret = ERROR_OUTOFMEMORY;
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}
773033de:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773033e1:	89 d8                	mov    %ebx,%eax
773033e3:	5b                   	pop    %ebx
773033e4:	5e                   	pop    %esi
773033e5:	5f                   	pop    %edi
773033e6:	5d                   	pop    %ebp
773033e7:	c2 0c 00             	ret    $0xc
773033ea:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
773033f0:	e8 fb e7 ff ff       	call   77301bf0 <_getInterfaceIndexTable>
773033f5:	bb 0e 00 00 00       	mov    $0xe,%ebx
773033fa:	85 c0                	test   %eax,%eax
773033fc:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
773033ff:	74 dd                	je     773033de <_GetIfTable@12+0x3e>
77303401:	8b 10                	mov    (%eax),%edx
77303403:	8d 04 52             	lea    (%edx,%edx,2),%eax
77303406:	8d 04 c0             	lea    (%eax,%eax,8),%eax
77303409:	c1 e0 03             	shl    $0x3,%eax
7730340c:	29 d0                	sub    %edx,%eax
7730340e:	8d 04 85 04 00 00 00 	lea    0x4(,%eax,4),%eax
77303415:	39 06                	cmp    %eax,(%esi)
77303417:	73 1f                	jae    77303438 <_GetIfTable@12+0x98>
77303419:	89 06                	mov    %eax,(%esi)
7730341b:	b3 7a                	mov    $0x7a,%bl
7730341d:	83 ec 0c             	sub    $0xc,%esp
77303420:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
77303423:	52                   	push   %edx
77303424:	e8 f7 4a 00 00       	call   77307f20 <_free>
77303429:	89 d8                	mov    %ebx,%eax
7730342b:	83 c4 10             	add    $0x10,%esp
7730342e:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77303431:	5b                   	pop    %ebx
77303432:	5e                   	pop    %esi
77303433:	5f                   	pop    %edi
77303434:	5d                   	pop    %ebp
77303435:	c2 0c 00             	ret    $0xc
77303438:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
7730343b:	c7 07 00 00 00 00    	movl   $0x0,(%edi)
77303441:	31 f6                	xor    %esi,%esi
77303443:	8b 00                	mov    (%eax),%eax
77303445:	85 c0                	test   %eax,%eax
77303447:	74 36                	je     7730347f <_GetIfTable@12+0xdf>
77303449:	89 fb                	mov    %edi,%ebx
7730344b:	90                   	nop    
7730344c:	8d 74 26 00          	lea    0x0(%esi),%esi
77303450:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
77303453:	83 ec 0c             	sub    $0xc,%esp
77303456:	8b 44 b2 08          	mov    0x8(%edx,%esi,4),%eax
7730345a:	46                   	inc    %esi
7730345b:	89 83 04 02 00 00    	mov    %eax,0x204(%ebx)
77303461:	8d 43 04             	lea    0x4(%ebx),%eax
77303464:	50                   	push   %eax
77303465:	e8 76 fe ff ff       	call   773032e0 <_GetIfEntry@4>
7730346a:	8b 07                	mov    (%edi),%eax
7730346c:	83 c4 0c             	add    $0xc,%esp
7730346f:	40                   	inc    %eax
77303470:	81 c3 5c 03 00 00    	add    $0x35c,%ebx
77303476:	89 07                	mov    %eax,(%edi)
77303478:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
7730347b:	39 30                	cmp    %esi,(%eax)
7730347d:	77 d1                	ja     77303450 <_GetIfTable@12+0xb0>
7730347f:	8b 5d 10             	mov    0x10(%ebp),%ebx
77303482:	85 db                	test   %ebx,%ebx
77303484:	75 04                	jne    7730348a <_GetIfTable@12+0xea>
77303486:	31 db                	xor    %ebx,%ebx
77303488:	eb 93                	jmp    7730341d <_GetIfTable@12+0x7d>
7730348a:	68 60 33 30 77       	push   $0x77303360
7730348f:	68 5c 03 00 00       	push   $0x35c
77303494:	8b 0f                	mov    (%edi),%ecx
77303496:	8d 47 04             	lea    0x4(%edi),%eax
77303499:	51                   	push   %ecx
7730349a:	50                   	push   %eax
7730349b:	e8 20 45 00 00       	call   773079c0 <_qsort>
773034a0:	31 db                	xor    %ebx,%ebx
773034a2:	83 c4 10             	add    $0x10,%esp
773034a5:	e9 73 ff ff ff       	jmp    7730341d <_GetIfTable@12+0x7d>
773034aa:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

773034b0 <_AllocateAndGetIfTableFromStack@16>:
773034b0:	55                   	push   %ebp
773034b1:	b8 57 00 00 00       	mov    $0x57,%eax
773034b6:	89 e5                	mov    %esp,%ebp
773034b8:	57                   	push   %edi
773034b9:	56                   	push   %esi
773034ba:	53                   	push   %ebx
773034bb:	83 ec 0c             	sub    $0xc,%esp
773034be:	8b 5d 08             	mov    0x8(%ebp),%ebx
773034c1:	8b 7d 0c             	mov    0xc(%ebp),%edi
773034c4:	85 db                	test   %ebx,%ebx
773034c6:	74 1b                	je     773034e3 <_AllocateAndGetIfTableFromStack@16+0x33>
773034c8:	56                   	push   %esi
773034c9:	8d 75 f0             	lea    0xfffffff0(%ebp),%esi
773034cc:	57                   	push   %edi
773034cd:	56                   	push   %esi
773034ce:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
773034d5:	8b 0b                	mov    (%ebx),%ecx
773034d7:	51                   	push   %ecx
773034d8:	e8 c3 fe ff ff       	call   773033a0 <_GetIfTable@12>
773034dd:	5a                   	pop    %edx
773034de:	83 f8 7a             	cmp    $0x7a,%eax
773034e1:	74 0a                	je     773034ed <_AllocateAndGetIfTableFromStack@16+0x3d>
773034e3:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773034e6:	5b                   	pop    %ebx
773034e7:	5e                   	pop    %esi
773034e8:	5f                   	pop    %edi
773034e9:	5d                   	pop    %ebp
773034ea:	c2 10 00             	ret    $0x10
773034ed:	50                   	push   %eax
773034ee:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
773034f1:	8b 4d 10             	mov    0x10(%ebp),%ecx
773034f4:	50                   	push   %eax
773034f5:	8b 45 14             	mov    0x14(%ebp),%eax
773034f8:	50                   	push   %eax
773034f9:	51                   	push   %ecx
773034fa:	e8 41 1f 00 00       	call   77305440 <_HeapAlloc@12>
773034ff:	89 03                	mov    %eax,(%ebx)
77303501:	57                   	push   %edi
77303502:	56                   	push   %esi
77303503:	50                   	push   %eax
77303504:	e8 97 fe ff ff       	call   773033a0 <_GetIfTable@12>
77303509:	5a                   	pop    %edx
7730350a:	eb d7                	jmp    773034e3 <_AllocateAndGetIfTableFromStack@16+0x33>
7730350c:	8d 74 26 00          	lea    0x0(%esi),%esi

77303510 <_GetInterfaceInfo@8>:


/******************************************************************
 *    GetInterfaceInfo (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pIfTable [In/Out]
 *  dwOutBufLen [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetInterfaceInfo(PIP_INTERFACE_INFO pIfTable, PULONG dwOutBufLen)
{
77303510:	55                   	push   %ebp
77303511:	89 e5                	mov    %esp,%ebp
77303513:	57                   	push   %edi
77303514:	56                   	push   %esi
77303515:	53                   	push   %ebx
77303516:	83 ec 1c             	sub    $0x1c,%esp
  DWORD ret;

  TRACE("pIfTable %p, dwOutBufLen %p\n", pIfTable, dwOutBufLen);
  if (!dwOutBufLen)
    ret = ERROR_INVALID_PARAMETER;
77303519:	bb 57 00 00 00       	mov    $0x57,%ebx
7730351e:	8b 75 0c             	mov    0xc(%ebp),%esi
77303521:	85 f6                	test   %esi,%esi
77303523:	74 25                	je     7730354a <_GetInterfaceInfo@8+0x3a>
  else {
    DWORD numInterfaces = getNumInterfaces();
77303525:	e8 96 e2 ff ff       	call   773017c0 <_getNumInterfaces>
    ULONG size = sizeof(IP_INTERFACE_INFO) + (numInterfaces - 1) *
     sizeof(IP_ADAPTER_INDEX_MAP);

    if (!pIfTable || *dwOutBufLen < size) {
7730352a:	8b 7d 08             	mov    0x8(%ebp),%edi
7730352d:	89 c2                	mov    %eax,%edx
7730352f:	c1 e2 06             	shl    $0x6,%edx
77303532:	01 c2                	add    %eax,%edx
77303534:	85 ff                	test   %edi,%edi
77303536:	8d 04 95 04 00 00 00 	lea    0x4(,%edx,4),%eax
7730353d:	74 04                	je     77303543 <_GetInterfaceInfo@8+0x33>
7730353f:	39 06                	cmp    %eax,(%esi)
77303541:	73 13                	jae    77303556 <_GetInterfaceInfo@8+0x46>
      *dwOutBufLen = size;
77303543:	89 06                	mov    %eax,(%esi)
      ret = ERROR_INSUFFICIENT_BUFFER;
77303545:	bb 7a 00 00 00       	mov    $0x7a,%ebx
    }
    else {
      InterfaceIndexTable *table = getInterfaceIndexTable();

      if (table) {
        size = sizeof(IP_INTERFACE_INFO) + (table->numIndexes - 1) *
         sizeof(IP_ADAPTER_INDEX_MAP);
        if (*dwOutBufLen < size) {
          *dwOutBufLen = size;
          ret = ERROR_INSUFFICIENT_BUFFER;
        }
        else {
          DWORD ndx;

          pIfTable->NumAdapters = 0;
          for (ndx = 0; ndx < table->numIndexes; ndx++) {
            const char *walker, *name;
            WCHAR *assigner;

            pIfTable->Adapter[ndx].Index = table->indexes[ndx];
            name = getInterfaceNameByIndex(table->indexes[ndx]);
            for (walker = name, assigner = pIfTable->Adapter[ndx].Name;
             walker && *walker &&
             assigner - pIfTable->Adapter[ndx].Name < MAX_ADAPTER_NAME - 1;
             walker++, assigner++)
              *assigner = *walker;
            *assigner = 0;
            consumeInterfaceName(name);
            pIfTable->NumAdapters++;
          }
          ret = NO_ERROR;
        }
        free(table);
      }
      else
        ret = ERROR_OUTOFMEMORY;
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}
7730354a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
7730354d:	89 d8                	mov    %ebx,%eax
7730354f:	5b                   	pop    %ebx
77303550:	5e                   	pop    %esi
77303551:	5f                   	pop    %edi
77303552:	5d                   	pop    %ebp
77303553:	c2 08 00             	ret    $0x8
77303556:	e8 95 e6 ff ff       	call   77301bf0 <_getInterfaceIndexTable>
7730355b:	bb 0e 00 00 00       	mov    $0xe,%ebx
77303560:	85 c0                	test   %eax,%eax
77303562:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
77303565:	74 e3                	je     7730354a <_GetInterfaceInfo@8+0x3a>
77303567:	8b 10                	mov    (%eax),%edx
77303569:	89 d0                	mov    %edx,%eax
7730356b:	c1 e0 06             	shl    $0x6,%eax
7730356e:	01 d0                	add    %edx,%eax
77303570:	8d 04 85 04 00 00 00 	lea    0x4(,%eax,4),%eax
77303577:	39 06                	cmp    %eax,(%esi)
77303579:	73 1f                	jae    7730359a <_GetInterfaceInfo@8+0x8a>
7730357b:	89 06                	mov    %eax,(%esi)
7730357d:	b3 7a                	mov    $0x7a,%bl
7730357f:	83 ec 0c             	sub    $0xc,%esp
77303582:	8b 7d f0             	mov    0xfffffff0(%ebp),%edi
77303585:	57                   	push   %edi
77303586:	e8 95 49 00 00       	call   77307f20 <_free>
7730358b:	89 d8                	mov    %ebx,%eax
7730358d:	83 c4 10             	add    $0x10,%esp
77303590:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77303593:	5b                   	pop    %ebx
77303594:	5e                   	pop    %esi
77303595:	5f                   	pop    %edi
77303596:	5d                   	pop    %ebp
77303597:	c2 08 00             	ret    $0x8
7730359a:	8b 45 08             	mov    0x8(%ebp),%eax
7730359d:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
773035a0:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
773035a7:	c7 00 00 00 00 00    	movl   $0x0,(%eax)
773035ad:	8b 32                	mov    (%edx),%esi
773035af:	85 f6                	test   %esi,%esi
773035b1:	0f 84 bd 00 00 00    	je     77303674 <_GetInterfaceInfo@8+0x164>
773035b7:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
773035ba:	f7 d8                	neg    %eax
773035bc:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
773035bf:	90                   	nop    
773035c0:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
773035c3:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
773035c6:	83 ec 0c             	sub    $0xc,%esp
773035c9:	8b 44 8a 08          	mov    0x8(%edx,%ecx,4),%eax
773035cd:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
773035d0:	89 41 04             	mov    %eax,0x4(%ecx)
773035d3:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
773035d6:	8b 5c 82 08          	mov    0x8(%edx,%eax,4),%ebx
773035da:	53                   	push   %ebx
773035db:	e8 e0 e3 ff ff       	call   773019c0 <_getInterfaceNameByIndex>
773035e0:	8b 75 e8             	mov    0xffffffe8(%ebp),%esi
773035e3:	83 c4 10             	add    $0x10,%esp
773035e6:	83 c6 08             	add    $0x8,%esi
773035e9:	89 c7                	mov    %eax,%edi
773035eb:	89 c3                	mov    %eax,%ebx
773035ed:	85 c0                	test   %eax,%eax
773035ef:	74 3f                	je     77303630 <_GetInterfaceInfo@8+0x120>
773035f1:	8a 10                	mov    (%eax),%dl
773035f3:	84 d2                	test   %dl,%dl
773035f5:	74 39                	je     77303630 <_GetInterfaceInfo@8+0x120>
773035f7:	89 f0                	mov    %esi,%eax
773035f9:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
773035fc:	29 c8                	sub    %ecx,%eax
773035fe:	83 e8 08             	sub    $0x8,%eax
77303601:	d1 f8                	sar    %eax
77303603:	83 f8 7e             	cmp    $0x7e,%eax
77303606:	7f 28                	jg     77303630 <_GetInterfaceInfo@8+0x120>
77303608:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
7730360b:	8d 4c 06 f8          	lea    0xfffffff8(%esi,%eax,1),%ecx
7730360f:	90                   	nop    
77303610:	66 0f be c2          	movsbw %dl,%ax
77303614:	66 89 06             	mov    %ax,(%esi)
77303617:	83 c1 02             	add    $0x2,%ecx
7730361a:	83 c6 02             	add    $0x2,%esi
7730361d:	43                   	inc    %ebx
7730361e:	74 10                	je     77303630 <_GetInterfaceInfo@8+0x120>
77303620:	8a 13                	mov    (%ebx),%dl
77303622:	84 d2                	test   %dl,%dl
77303624:	74 0a                	je     77303630 <_GetInterfaceInfo@8+0x120>
77303626:	89 c8                	mov    %ecx,%eax
77303628:	d1 f8                	sar    %eax
7730362a:	83 f8 7e             	cmp    $0x7e,%eax
7730362d:	7e e1                	jle    77303610 <_GetInterfaceInfo@8+0x100>
7730362f:	90                   	nop    
77303630:	83 ec 0c             	sub    $0xc,%esp
77303633:	66 c7 06 00 00       	movw   $0x0,(%esi)
77303638:	57                   	push   %edi
77303639:	e8 12 e4 ff ff       	call   77301a50 <_consumeInterfaceName>
7730363e:	8b 55 08             	mov    0x8(%ebp),%edx
77303641:	83 c4 10             	add    $0x10,%esp
77303644:	8b 02                	mov    (%edx),%eax
77303646:	40                   	inc    %eax
77303647:	89 02                	mov    %eax,(%edx)
77303649:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
7730364c:	40                   	inc    %eax
7730364d:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
77303650:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
77303653:	2d 04 01 00 00       	sub    $0x104,%eax
77303658:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
7730365b:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
7730365e:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
77303661:	05 04 01 00 00       	add    $0x104,%eax
77303666:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
77303669:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
7730366c:	39 08                	cmp    %ecx,(%eax)
7730366e:	0f 87 4c ff ff ff    	ja     773035c0 <_GetInterfaceInfo@8+0xb0>
77303674:	31 db                	xor    %ebx,%ebx
77303676:	e9 04 ff ff ff       	jmp    7730357f <_GetInterfaceInfo@8+0x6f>
7730367b:	90                   	nop    
7730367c:	8d 74 26 00          	lea    0x0(%esi),%esi

77303680 <_IpAddrTableSorter>:


static int IpAddrTableSorter(const void *a, const void *b)
{
77303680:	55                   	push   %ebp
77303681:	89 e5                	mov    %esp,%ebp
77303683:	56                   	push   %esi
77303684:	53                   	push   %ebx
77303685:	8b 75 0c             	mov    0xc(%ebp),%esi
77303688:	8b 5d 08             	mov    0x8(%ebp),%ebx
  int ret;

  if (a && b)
7730368b:	85 db                	test   %ebx,%ebx
7730368d:	0f 95 c2             	setne  %dl
77303690:	85 f6                	test   %esi,%esi
77303692:	0f 95 c0             	setne  %al
77303695:	25 ff 00 00 00       	and    $0xff,%eax
    ret = ((PMIB_IPADDRROW)a)->dwAddr - ((PMIB_IPADDRROW)b)->dwAddr;
  else
    ret = 0;
7730369a:	31 c9                	xor    %ecx,%ecx
7730369c:	85 c2                	test   %eax,%edx
7730369e:	74 06                	je     773036a6 <_IpAddrTableSorter+0x26>
773036a0:	8b 0b                	mov    (%ebx),%ecx
773036a2:	8b 06                	mov    (%esi),%eax
773036a4:	29 c1                	sub    %eax,%ecx
  return ret;
}
773036a6:	89 c8                	mov    %ecx,%eax
773036a8:	5b                   	pop    %ebx
773036a9:	5e                   	pop    %esi
773036aa:	5d                   	pop    %ebp
773036ab:	c3                   	ret    
773036ac:	8d 74 26 00          	lea    0x0(%esi),%esi

773036b0 <_GetIpAddrTable@12>:


/******************************************************************
 *    GetIpAddrTable (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pIpAddrTable [In/Out]
 *  pdwSize [In/Out]
 *  bOrder [In]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetIpAddrTable(PMIB_IPADDRTABLE pIpAddrTable, PULONG pdwSize, BOOL bOrder)
{
773036b0:	55                   	push   %ebp
773036b1:	89 e5                	mov    %esp,%ebp
773036b3:	57                   	push   %edi
773036b4:	56                   	push   %esi
773036b5:	53                   	push   %ebx
773036b6:	83 ec 0c             	sub    $0xc,%esp
  DWORD ret;

  TRACE("pIpAddrTable %p, pdwSize %p, bOrder %ld\n", pIpAddrTable, pdwSize,
   (DWORD)bOrder);
  if (!pdwSize)
    ret = ERROR_INVALID_PARAMETER;
773036b9:	bb 57 00 00 00       	mov    $0x57,%ebx
773036be:	8b 7d 0c             	mov    0xc(%ebp),%edi
773036c1:	85 ff                	test   %edi,%edi
773036c3:	74 21                	je     773036e6 <_GetIpAddrTable@12+0x36>
  else {
    DWORD numInterfaces = getNumInterfaces();
773036c5:	e8 f6 e0 ff ff       	call   773017c0 <_getNumInterfaces>
    ULONG size = sizeof(MIB_IPADDRTABLE) + (numInterfaces - 1) *
     sizeof(MIB_IPADDRROW);

    if (!pIpAddrTable || *pdwSize < size) {
773036ca:	8b 4d 08             	mov    0x8(%ebp),%ecx
773036cd:	85 c9                	test   %ecx,%ecx
773036cf:	8d 04 40             	lea    (%eax,%eax,2),%eax
773036d2:	8d 04 c5 04 00 00 00 	lea    0x4(,%eax,8),%eax
773036d9:	74 04                	je     773036df <_GetIpAddrTable@12+0x2f>
773036db:	39 07                	cmp    %eax,(%edi)
773036dd:	73 13                	jae    773036f2 <_GetIpAddrTable@12+0x42>
      *pdwSize = size;
773036df:	89 07                	mov    %eax,(%edi)
      ret = ERROR_INSUFFICIENT_BUFFER;
773036e1:	bb 7a 00 00 00       	mov    $0x7a,%ebx
    }
    else {
      InterfaceIndexTable *table = getInterfaceIndexTable();

      if (table) {
        size = sizeof(MIB_IPADDRTABLE) + (table->numIndexes - 1) *
         sizeof(MIB_IPADDRROW);
        if (*pdwSize < size) {
          *pdwSize = size;
          ret = ERROR_INSUFFICIENT_BUFFER;
        }
        else {
          DWORD ndx, bcast;

          pIpAddrTable->dwNumEntries = 0;
          for (ndx = 0; ndx < table->numIndexes; ndx++) {
            pIpAddrTable->table[ndx].dwIndex = table->indexes[ndx];
            pIpAddrTable->table[ndx].dwAddr =
             getInterfaceIPAddrByIndex(table->indexes[ndx]);
            pIpAddrTable->table[ndx].dwMask =
             getInterfaceMaskByIndex(table->indexes[ndx]);
            /* the dwBCastAddr member isn't the broadcast address, it indicates
             * whether the interface uses the 1's broadcast address (1) or the
             * 0's broadcast address (0).
             */
            bcast = getInterfaceBCastAddrByIndex(table->indexes[ndx]);
            pIpAddrTable->table[ndx].dwBCastAddr =
             (bcast & pIpAddrTable->table[ndx].dwMask) ? 1 : 0;
            /* FIXME: hardcoded reasm size, not sure where to get it */
            pIpAddrTable->table[ndx].dwReasmSize = 65535;
            pIpAddrTable->table[ndx].unused1 = 0;
            pIpAddrTable->table[ndx].wType = 0; /* aka unused2 */
            pIpAddrTable->dwNumEntries++;
          }
          if (bOrder)
            qsort(pIpAddrTable->table, pIpAddrTable->dwNumEntries,
             sizeof(MIB_IPADDRROW), IpAddrTableSorter);
          ret = NO_ERROR;
        }
        free(table);
      }
      else
        ret = ERROR_OUTOFMEMORY;
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}
773036e6:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773036e9:	89 d8                	mov    %ebx,%eax
773036eb:	5b                   	pop    %ebx
773036ec:	5e                   	pop    %esi
773036ed:	5f                   	pop    %edi
773036ee:	5d                   	pop    %ebp
773036ef:	c2 0c 00             	ret    $0xc
773036f2:	e8 f9 e4 ff ff       	call   77301bf0 <_getInterfaceIndexTable>
773036f7:	bb 0e 00 00 00       	mov    $0xe,%ebx
773036fc:	89 c6                	mov    %eax,%esi
773036fe:	85 c0                	test   %eax,%eax
77303700:	74 e4                	je     773036e6 <_GetIpAddrTable@12+0x36>
77303702:	8b 00                	mov    (%eax),%eax
77303704:	8d 04 40             	lea    (%eax,%eax,2),%eax
77303707:	8d 04 c5 04 00 00 00 	lea    0x4(,%eax,8),%eax
7730370e:	39 07                	cmp    %eax,(%edi)
77303710:	73 1c                	jae    7730372e <_GetIpAddrTable@12+0x7e>
77303712:	89 07                	mov    %eax,(%edi)
77303714:	b3 7a                	mov    $0x7a,%bl
77303716:	83 ec 0c             	sub    $0xc,%esp
77303719:	56                   	push   %esi
7730371a:	e8 01 48 00 00       	call   77307f20 <_free>
7730371f:	89 d8                	mov    %ebx,%eax
77303721:	83 c4 10             	add    $0x10,%esp
77303724:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77303727:	5b                   	pop    %ebx
77303728:	5e                   	pop    %esi
77303729:	5f                   	pop    %edi
7730372a:	5d                   	pop    %ebp
7730372b:	c2 0c 00             	ret    $0xc
7730372e:	8b 45 08             	mov    0x8(%ebp),%eax
77303731:	31 ff                	xor    %edi,%edi
77303733:	c7 00 00 00 00 00    	movl   $0x0,(%eax)
77303739:	8b 16                	mov    (%esi),%edx
7730373b:	85 d2                	test   %edx,%edx
7730373d:	74 66                	je     773037a5 <_GetIpAddrTable@12+0xf5>
7730373f:	89 c3                	mov    %eax,%ebx
77303741:	8b 44 be 08          	mov    0x8(%esi,%edi,4),%eax
77303745:	83 ec 0c             	sub    $0xc,%esp
77303748:	89 43 08             	mov    %eax,0x8(%ebx)
7730374b:	8b 44 be 08          	mov    0x8(%esi,%edi,4),%eax
7730374f:	50                   	push   %eax
77303750:	e8 9b e5 ff ff       	call   77301cf0 <_getInterfaceIPAddrByIndex>
77303755:	89 43 04             	mov    %eax,0x4(%ebx)
77303758:	58                   	pop    %eax
77303759:	8b 44 be 08          	mov    0x8(%esi,%edi,4),%eax
7730375d:	50                   	push   %eax
7730375e:	e8 0d e6 ff ff       	call   77301d70 <_getInterfaceMaskByIndex>
77303763:	89 43 0c             	mov    %eax,0xc(%ebx)
77303766:	58                   	pop    %eax
77303767:	8b 4c be 08          	mov    0x8(%esi,%edi,4),%ecx
7730376b:	51                   	push   %ecx
7730376c:	e8 bf e5 ff ff       	call   77301d30 <_getInterfaceBCastAddrByIndex>
77303771:	83 c4 10             	add    $0x10,%esp
77303774:	c7 43 14 ff ff 00 00 	movl   $0xffff,0x14(%ebx)
7730377b:	85 43 0c             	test   %eax,0xc(%ebx)
7730377e:	66 c7 43 18 00 00    	movw   $0x0,0x18(%ebx)
77303784:	0f 95 c0             	setne  %al
77303787:	25 ff 00 00 00       	and    $0xff,%eax
7730378c:	47                   	inc    %edi
7730378d:	89 43 10             	mov    %eax,0x10(%ebx)
77303790:	8b 45 08             	mov    0x8(%ebp),%eax
77303793:	66 c7 43 1a 00 00    	movw   $0x0,0x1a(%ebx)
77303799:	83 c3 18             	add    $0x18,%ebx
7730379c:	8b 10                	mov    (%eax),%edx
7730379e:	42                   	inc    %edx
7730379f:	89 10                	mov    %edx,(%eax)
773037a1:	39 3e                	cmp    %edi,(%esi)
773037a3:	77 9c                	ja     77303741 <_GetIpAddrTable@12+0x91>
773037a5:	8b 4d 10             	mov    0x10(%ebp),%ecx
773037a8:	85 c9                	test   %ecx,%ecx
773037aa:	75 07                	jne    773037b3 <_GetIpAddrTable@12+0x103>
773037ac:	31 db                	xor    %ebx,%ebx
773037ae:	e9 63 ff ff ff       	jmp    77303716 <_GetIpAddrTable@12+0x66>
773037b3:	68 80 36 30 77       	push   $0x77303680
773037b8:	6a 18                	push   $0x18
773037ba:	8b 45 08             	mov    0x8(%ebp),%eax
773037bd:	31 db                	xor    %ebx,%ebx
773037bf:	8b 10                	mov    (%eax),%edx
773037c1:	83 c0 04             	add    $0x4,%eax
773037c4:	52                   	push   %edx
773037c5:	50                   	push   %eax
773037c6:	e8 f5 41 00 00       	call   773079c0 <_qsort>
773037cb:	83 c4 10             	add    $0x10,%esp
773037ce:	e9 43 ff ff ff       	jmp    77303716 <_GetIpAddrTable@12+0x66>
773037d3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
773037d9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

773037e0 <_AllocateAndGetIpAddrTableFromStack@16>:
773037e0:	55                   	push   %ebp
773037e1:	b8 57 00 00 00       	mov    $0x57,%eax
773037e6:	89 e5                	mov    %esp,%ebp
773037e8:	57                   	push   %edi
773037e9:	56                   	push   %esi
773037ea:	53                   	push   %ebx
773037eb:	83 ec 0c             	sub    $0xc,%esp
773037ee:	8b 5d 08             	mov    0x8(%ebp),%ebx
773037f1:	8b 7d 0c             	mov    0xc(%ebp),%edi
773037f4:	85 db                	test   %ebx,%ebx
773037f6:	74 1b                	je     77303813 <_AllocateAndGetIpAddrTableFromStack@16+0x33>
773037f8:	56                   	push   %esi
773037f9:	8d 75 f0             	lea    0xfffffff0(%ebp),%esi
773037fc:	57                   	push   %edi
773037fd:	56                   	push   %esi
773037fe:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
77303805:	8b 0b                	mov    (%ebx),%ecx
77303807:	51                   	push   %ecx
77303808:	e8 a3 fe ff ff       	call   773036b0 <_GetIpAddrTable@12>
7730380d:	5a                   	pop    %edx
7730380e:	83 f8 7a             	cmp    $0x7a,%eax
77303811:	74 0a                	je     7730381d <_AllocateAndGetIpAddrTableFromStack@16+0x3d>
77303813:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77303816:	5b                   	pop    %ebx
77303817:	5e                   	pop    %esi
77303818:	5f                   	pop    %edi
77303819:	5d                   	pop    %ebp
7730381a:	c2 10 00             	ret    $0x10
7730381d:	50                   	push   %eax
7730381e:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
77303821:	50                   	push   %eax
77303822:	8b 45 14             	mov    0x14(%ebp),%eax
77303825:	50                   	push   %eax
77303826:	8b 45 10             	mov    0x10(%ebp),%eax
77303829:	50                   	push   %eax
7730382a:	e8 11 1c 00 00       	call   77305440 <_HeapAlloc@12>
7730382f:	89 03                	mov    %eax,(%ebx)
77303831:	57                   	push   %edi
77303832:	56                   	push   %esi
77303833:	50                   	push   %eax
77303834:	e8 77 fe ff ff       	call   773036b0 <_GetIpAddrTable@12>
77303839:	5b                   	pop    %ebx
7730383a:	eb d7                	jmp    77303813 <_AllocateAndGetIpAddrTableFromStack@16+0x33>
7730383c:	8d 74 26 00          	lea    0x0(%esi),%esi

77303840 <_IpForwardTableSorter>:


static int IpForwardTableSorter(const void *a, const void *b)
{
77303840:	55                   	push   %ebp
77303841:	89 e5                	mov    %esp,%ebp
77303843:	56                   	push   %esi
77303844:	53                   	push   %ebx
77303845:	8b 75 08             	mov    0x8(%ebp),%esi
77303848:	8b 5d 0c             	mov    0xc(%ebp),%ebx
  int ret;

  if (a && b) {
7730384b:	85 f6                	test   %esi,%esi
7730384d:	0f 95 c2             	setne  %dl
77303850:	85 db                	test   %ebx,%ebx
77303852:	0f 95 c0             	setne  %al
77303855:	25 ff 00 00 00       	and    $0xff,%eax
    PMIB_IPFORWARDROW rowA = (PMIB_IPFORWARDROW)a, rowB = (PMIB_IPFORWARDROW)b;

    ret = rowA->dwForwardDest - rowB->dwForwardDest;
    if (ret == 0) {
      ret = rowA->dwForwardProto - rowB->dwForwardProto;
      if (ret == 0) {
        ret = rowA->dwForwardPolicy - rowB->dwForwardPolicy;
        if (ret == 0)
          ret = rowA->dwForwardNextHop - rowB->dwForwardNextHop;
      }
    }
  }
  else
    ret = 0;
7730385a:	31 c9                	xor    %ecx,%ecx
7730385c:	85 c2                	test   %eax,%edx
7730385e:	74 24                	je     77303884 <_IpForwardTableSorter+0x44>
77303860:	8b 06                	mov    (%esi),%eax
77303862:	89 c1                	mov    %eax,%ecx
77303864:	2b 0b                	sub    (%ebx),%ecx
77303866:	75 1c                	jne    77303884 <_IpForwardTableSorter+0x44>
77303868:	8b 46 18             	mov    0x18(%esi),%eax
7730386b:	89 c1                	mov    %eax,%ecx
7730386d:	2b 4b 18             	sub    0x18(%ebx),%ecx
77303870:	75 12                	jne    77303884 <_IpForwardTableSorter+0x44>
77303872:	8b 46 08             	mov    0x8(%esi),%eax
77303875:	89 c1                	mov    %eax,%ecx
77303877:	2b 4b 08             	sub    0x8(%ebx),%ecx
7730387a:	75 08                	jne    77303884 <_IpForwardTableSorter+0x44>
7730387c:	8b 4e 0c             	mov    0xc(%esi),%ecx
7730387f:	8b 43 0c             	mov    0xc(%ebx),%eax
77303882:	29 c1                	sub    %eax,%ecx
  return ret;
}
77303884:	89 c8                	mov    %ecx,%eax
77303886:	5b                   	pop    %ebx
77303887:	5e                   	pop    %esi
77303888:	5d                   	pop    %ebp
77303889:	c3                   	ret    
7730388a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

77303890 <_GetIpForwardTable@12>:


/******************************************************************
 *    GetIpForwardTable (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pIpForwardTable [In/Out]
 *  pdwSize [In/Out]
 *  bOrder [In]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetIpForwardTable(PMIB_IPFORWARDTABLE pIpForwardTable, PULONG pdwSize, BOOL bOrder)
{
77303890:	55                   	push   %ebp
77303891:	89 e5                	mov    %esp,%ebp
77303893:	57                   	push   %edi
77303894:	56                   	push   %esi
77303895:	53                   	push   %ebx
77303896:	83 ec 0c             	sub    $0xc,%esp
  DWORD ret;
  
  TRACE("pIpForwardTable %p, pdwSize %p, bOrder %ld\n", pIpForwardTable,
        pdwSize, (DWORD)bOrder);
  if (!pdwSize)
    ret = ERROR_INVALID_PARAMETER;
77303899:	bb 57 00 00 00       	mov    $0x57,%ebx
7730389e:	8b 7d 0c             	mov    0xc(%ebp),%edi
773038a1:	85 ff                	test   %edi,%edi
773038a3:	74 29                	je     773038ce <_GetIpForwardTable@12+0x3e>
  else {
    DWORD numRoutes = getNumRoutes();
773038a5:	e8 f6 ef ff ff       	call   773028a0 <_getNumRoutes>
    ULONG sizeNeeded = sizeof(MIB_IPFORWARDTABLE) + (numRoutes - 1) *
     sizeof(MIB_IPFORWARDROW);

    if (!pIpForwardTable || *pdwSize < sizeNeeded) {
773038aa:	8b 5d 08             	mov    0x8(%ebp),%ebx
773038ad:	89 c6                	mov    %eax,%esi
773038af:	8d 04 c5 00 00 00 00 	lea    0x0(,%eax,8),%eax
773038b6:	29 f0                	sub    %esi,%eax
773038b8:	85 db                	test   %ebx,%ebx
773038ba:	8d 04 c5 04 00 00 00 	lea    0x4(,%eax,8),%eax
773038c1:	74 04                	je     773038c7 <_GetIpForwardTable@12+0x37>
773038c3:	39 07                	cmp    %eax,(%edi)
773038c5:	73 19                	jae    773038e0 <_GetIpForwardTable@12+0x50>
      *pdwSize = sizeNeeded;
773038c7:	89 07                	mov    %eax,(%edi)
      ret = ERROR_INSUFFICIENT_BUFFER;
773038c9:	bb 7a 00 00 00       	mov    $0x7a,%ebx
    }
    else {
      RouteTable *table = getRouteTable();
      if (table) {
        sizeNeeded = sizeof(MIB_IPFORWARDTABLE) + (table->numRoutes - 1) *
         sizeof(MIB_IPFORWARDROW);
        if (*pdwSize < sizeNeeded) {
          *pdwSize = sizeNeeded;
          ret = ERROR_INSUFFICIENT_BUFFER;
        }
        else {
          DWORD ndx;

          pIpForwardTable->dwNumEntries = table->numRoutes;
          for (ndx = 0; ndx < numRoutes; ndx++) {
            pIpForwardTable->table[ndx].dwForwardIfIndex =
             table->routes[ndx].ifIndex;
            pIpForwardTable->table[ndx].dwForwardDest =
             table->routes[ndx].dest;
            pIpForwardTable->table[ndx].dwForwardMask =
             table->routes[ndx].mask;
            pIpForwardTable->table[ndx].dwForwardPolicy = 0;
            pIpForwardTable->table[ndx].dwForwardNextHop =
             table->routes[ndx].gateway;
            /* FIXME: this type is appropriate for local interfaces; may not
               always be appropriate */
            pIpForwardTable->table[ndx].dwForwardType = MIB_IPROUTE_TYPE_DIRECT;
            /* FIXME: other protos might be appropriate, e.g. the default route
               is typically set with MIB_IPPROTO_NETMGMT instead */
            pIpForwardTable->table[ndx].dwForwardProto = MIB_IPPROTO_LOCAL;
            /* punt on age and AS */
            pIpForwardTable->table[ndx].dwForwardAge = 0;
            pIpForwardTable->table[ndx].dwForwardNextHopAS = 0;
            pIpForwardTable->table[ndx].dwForwardMetric1 =
             table->routes[ndx].metric;
            /* rest of the metrics are 0.. */
            pIpForwardTable->table[ndx].dwForwardMetric2 = 0;
            pIpForwardTable->table[ndx].dwForwardMetric3 = 0;
            pIpForwardTable->table[ndx].dwForwardMetric4 = 0;
            pIpForwardTable->table[ndx].dwForwardMetric5 = 0;
          }
          if (bOrder)
            qsort(pIpForwardTable->table, pIpForwardTable->dwNumEntries,
             sizeof(MIB_IPFORWARDROW), IpForwardTableSorter);
          ret = NO_ERROR;
        }
        free(table);
      }
      else
        ret = ERROR_OUTOFMEMORY;
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}
773038ce:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773038d1:	89 d8                	mov    %ebx,%eax
773038d3:	5b                   	pop    %ebx
773038d4:	5e                   	pop    %esi
773038d5:	5f                   	pop    %edi
773038d6:	5d                   	pop    %ebp
773038d7:	c2 0c 00             	ret    $0xc
773038da:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
773038e0:	e8 2b f1 ff ff       	call   77302a10 <_getRouteTable>
773038e5:	bb 0e 00 00 00       	mov    $0xe,%ebx
773038ea:	85 c0                	test   %eax,%eax
773038ec:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
773038ef:	74 dd                	je     773038ce <_GetIpForwardTable@12+0x3e>
773038f1:	8b 10                	mov    (%eax),%edx
773038f3:	8d 04 d5 00 00 00 00 	lea    0x0(,%edx,8),%eax
773038fa:	29 d0                	sub    %edx,%eax
773038fc:	8d 04 c5 04 00 00 00 	lea    0x4(,%eax,8),%eax
77303903:	39 07                	cmp    %eax,(%edi)
77303905:	73 1f                	jae    77303926 <_GetIpForwardTable@12+0x96>
77303907:	89 07                	mov    %eax,(%edi)
77303909:	b3 7a                	mov    $0x7a,%bl
7730390b:	83 ec 0c             	sub    $0xc,%esp
7730390e:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
77303911:	50                   	push   %eax
77303912:	e8 09 46 00 00       	call   77307f20 <_free>
77303917:	89 d8                	mov    %ebx,%eax
77303919:	83 c4 10             	add    $0x10,%esp
7730391c:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
7730391f:	5b                   	pop    %ebx
77303920:	5e                   	pop    %esi
77303921:	5f                   	pop    %edi
77303922:	5d                   	pop    %ebp
77303923:	c2 0c 00             	ret    $0xc
77303926:	8b 45 08             	mov    0x8(%ebp),%eax
77303929:	85 f6                	test   %esi,%esi
7730392b:	89 10                	mov    %edx,(%eax)
7730392d:	74 6d                	je     7730399c <_GetIpForwardTable@12+0x10c>
7730392f:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
77303932:	89 c2                	mov    %eax,%edx
77303934:	89 f3                	mov    %esi,%ebx
77303936:	8b 41 10             	mov    0x10(%ecx),%eax
77303939:	89 42 14             	mov    %eax,0x14(%edx)
7730393c:	8b 41 04             	mov    0x4(%ecx),%eax
7730393f:	89 42 04             	mov    %eax,0x4(%edx)
77303942:	8b 41 08             	mov    0x8(%ecx),%eax
77303945:	c7 42 0c 00 00 00 00 	movl   $0x0,0xc(%edx)
7730394c:	89 42 08             	mov    %eax,0x8(%edx)
7730394f:	8b 41 0c             	mov    0xc(%ecx),%eax
77303952:	c7 42 18 03 00 00 00 	movl   $0x3,0x18(%edx)
77303959:	89 42 10             	mov    %eax,0x10(%edx)
7730395c:	c7 42 1c 02 00 00 00 	movl   $0x2,0x1c(%edx)
77303963:	c7 42 20 00 00 00 00 	movl   $0x0,0x20(%edx)
7730396a:	c7 42 24 00 00 00 00 	movl   $0x0,0x24(%edx)
77303971:	8b 41 14             	mov    0x14(%ecx),%eax
77303974:	c7 42 2c 00 00 00 00 	movl   $0x0,0x2c(%edx)
7730397b:	89 42 28             	mov    %eax,0x28(%edx)
7730397e:	c7 42 30 00 00 00 00 	movl   $0x0,0x30(%edx)
77303985:	c7 42 34 00 00 00 00 	movl   $0x0,0x34(%edx)
7730398c:	c7 42 38 00 00 00 00 	movl   $0x0,0x38(%edx)
77303993:	83 c1 14             	add    $0x14,%ecx
77303996:	83 c2 38             	add    $0x38,%edx
77303999:	4b                   	dec    %ebx
7730399a:	75 9a                	jne    77303936 <_GetIpForwardTable@12+0xa6>
7730399c:	8b 4d 10             	mov    0x10(%ebp),%ecx
7730399f:	85 c9                	test   %ecx,%ecx
773039a1:	75 07                	jne    773039aa <_GetIpForwardTable@12+0x11a>
773039a3:	31 db                	xor    %ebx,%ebx
773039a5:	e9 61 ff ff ff       	jmp    7730390b <_GetIpForwardTable@12+0x7b>
773039aa:	68 40 38 30 77       	push   $0x77303840
773039af:	6a 38                	push   $0x38
773039b1:	8b 45 08             	mov    0x8(%ebp),%eax
773039b4:	31 db                	xor    %ebx,%ebx
773039b6:	8b 10                	mov    (%eax),%edx
773039b8:	83 c0 04             	add    $0x4,%eax
773039bb:	52                   	push   %edx
773039bc:	50                   	push   %eax
773039bd:	e8 fe 3f 00 00       	call   773079c0 <_qsort>
773039c2:	83 c4 10             	add    $0x10,%esp
773039c5:	e9 41 ff ff ff       	jmp    7730390b <_GetIpForwardTable@12+0x7b>
773039ca:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

773039d0 <_AllocateAndGetIpForwardTableFromStack@16>:
773039d0:	55                   	push   %ebp
773039d1:	b8 57 00 00 00       	mov    $0x57,%eax
773039d6:	89 e5                	mov    %esp,%ebp
773039d8:	57                   	push   %edi
773039d9:	56                   	push   %esi
773039da:	53                   	push   %ebx
773039db:	83 ec 0c             	sub    $0xc,%esp
773039de:	8b 5d 08             	mov    0x8(%ebp),%ebx
773039e1:	8b 7d 0c             	mov    0xc(%ebp),%edi
773039e4:	85 db                	test   %ebx,%ebx
773039e6:	74 1b                	je     77303a03 <_AllocateAndGetIpForwardTableFromStack@16+0x33>
773039e8:	56                   	push   %esi
773039e9:	8d 75 f0             	lea    0xfffffff0(%ebp),%esi
773039ec:	57                   	push   %edi
773039ed:	56                   	push   %esi
773039ee:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
773039f5:	8b 0b                	mov    (%ebx),%ecx
773039f7:	51                   	push   %ecx
773039f8:	e8 93 fe ff ff       	call   77303890 <_GetIpForwardTable@12>
773039fd:	5a                   	pop    %edx
773039fe:	83 f8 7a             	cmp    $0x7a,%eax
77303a01:	74 0a                	je     77303a0d <_AllocateAndGetIpForwardTableFromStack@16+0x3d>
77303a03:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77303a06:	5b                   	pop    %ebx
77303a07:	5e                   	pop    %esi
77303a08:	5f                   	pop    %edi
77303a09:	5d                   	pop    %ebp
77303a0a:	c2 10 00             	ret    $0x10
77303a0d:	50                   	push   %eax
77303a0e:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
77303a11:	50                   	push   %eax
77303a12:	8b 45 14             	mov    0x14(%ebp),%eax
77303a15:	50                   	push   %eax
77303a16:	8b 45 10             	mov    0x10(%ebp),%eax
77303a19:	50                   	push   %eax
77303a1a:	e8 21 1a 00 00       	call   77305440 <_HeapAlloc@12>
77303a1f:	89 03                	mov    %eax,(%ebx)
77303a21:	57                   	push   %edi
77303a22:	56                   	push   %esi
77303a23:	50                   	push   %eax
77303a24:	e8 67 fe ff ff       	call   77303890 <_GetIpForwardTable@12>
77303a29:	5e                   	pop    %esi
77303a2a:	eb d7                	jmp    77303a03 <_AllocateAndGetIpForwardTableFromStack@16+0x33>
77303a2c:	8d 74 26 00          	lea    0x0(%esi),%esi

77303a30 <_GetBestRoute@12>:
77303a30:	55                   	push   %ebp
77303a31:	b8 57 00 00 00       	mov    $0x57,%eax
77303a36:	89 e5                	mov    %esp,%ebp
77303a38:	57                   	push   %edi
77303a39:	56                   	push   %esi
77303a3a:	53                   	push   %ebx
77303a3b:	83 ec 1c             	sub    $0x1c,%esp
77303a3e:	8b 55 10             	mov    0x10(%ebp),%edx
77303a41:	85 d2                	test   %edx,%edx
77303a43:	0f 84 b9 00 00 00    	je     77303b02 <_GetBestRoute@12+0xd2>
77303a49:	6a 00                	push   $0x0
77303a4b:	83 ec 0c             	sub    $0xc,%esp
77303a4e:	e8 dd 19 00 00       	call   77305430 <_GetProcessHeap@0>
77303a53:	83 c4 0c             	add    $0xc,%esp
77303a56:	50                   	push   %eax
77303a57:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
77303a5a:	6a 00                	push   $0x0
77303a5c:	50                   	push   %eax
77303a5d:	e8 6e ff ff ff       	call   773039d0 <_AllocateAndGetIpForwardTableFromStack@16>
77303a62:	8b 5d f0             	mov    0xfffffff0(%ebp),%ebx
77303a65:	b8 0e 00 00 00       	mov    $0xe,%eax
77303a6a:	85 db                	test   %ebx,%ebx
77303a6c:	0f 84 90 00 00 00    	je     77303b02 <_GetBestRoute@12+0xd2>
77303a72:	8b 03                	mov    (%ebx),%eax
77303a74:	31 ff                	xor    %edi,%edi
77303a76:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
77303a7d:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
77303a84:	83 f8 00             	cmp    $0x0,%eax
77303a87:	76 4a                	jbe    77303ad3 <_GetBestRoute@12+0xa3>
77303a89:	89 de                	mov    %ebx,%esi
77303a8b:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
77303a8e:	eb 09                	jmp    77303a99 <_GetBestRoute@12+0x69>
77303a90:	47                   	inc    %edi
77303a91:	83 c6 38             	add    $0x38,%esi
77303a94:	39 7d e4             	cmp    %edi,0xffffffe4(%ebp)
77303a97:	76 3a                	jbe    77303ad3 <_GetBestRoute@12+0xa3>
77303a99:	8b 4e 08             	mov    0x8(%esi),%ecx
77303a9c:	8b 55 08             	mov    0x8(%ebp),%edx
77303a9f:	8b 46 04             	mov    0x4(%esi),%eax
77303aa2:	21 ca                	and    %ecx,%edx
77303aa4:	21 c8                	and    %ecx,%eax
77303aa6:	39 c2                	cmp    %eax,%edx
77303aa8:	75 e6                	jne    77303a90 <_GetBestRoute@12+0x60>
77303aaa:	31 d2                	xor    %edx,%edx
77303aac:	89 c8                	mov    %ecx,%eax
77303aae:	85 c9                	test   %ecx,%ecx
77303ab0:	74 de                	je     77303a90 <_GetBestRoute@12+0x60>
77303ab2:	a8 01                	test   $0x1,%al
77303ab4:	75 da                	jne    77303a90 <_GetBestRoute@12+0x60>
77303ab6:	42                   	inc    %edx
77303ab7:	d1 e8                	shr    %eax
77303ab9:	74 04                	je     77303abf <_GetBestRoute@12+0x8f>
77303abb:	a8 01                	test   $0x1,%al
77303abd:	74 f7                	je     77303ab6 <_GetBestRoute@12+0x86>
77303abf:	3b 55 ec             	cmp    0xffffffec(%ebp),%edx
77303ac2:	76 cc                	jbe    77303a90 <_GetBestRoute@12+0x60>
77303ac4:	89 7d e8             	mov    %edi,0xffffffe8(%ebp)
77303ac7:	47                   	inc    %edi
77303ac8:	83 c6 38             	add    $0x38,%esi
77303acb:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
77303ace:	39 7d e4             	cmp    %edi,0xffffffe4(%ebp)
77303ad1:	77 c6                	ja     77303a99 <_GetBestRoute@12+0x69>
77303ad3:	8b 75 e8             	mov    0xffffffe8(%ebp),%esi
77303ad6:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
77303ad9:	c1 e6 03             	shl    $0x3,%esi
77303adc:	8b 7d 10             	mov    0x10(%ebp),%edi
77303adf:	29 c6                	sub    %eax,%esi
77303ae1:	b9 0e 00 00 00       	mov    $0xe,%ecx
77303ae6:	fc                   	cld    
77303ae7:	8d 74 f3 04          	lea    0x4(%ebx,%esi,8),%esi
77303aeb:	f3 a5                	repz movsl %ds:(%esi),%es:(%edi)
77303aed:	50                   	push   %eax
77303aee:	53                   	push   %ebx
77303aef:	6a 00                	push   $0x0
77303af1:	50                   	push   %eax
77303af2:	e8 39 19 00 00       	call   77305430 <_GetProcessHeap@0>
77303af7:	89 04 24             	mov    %eax,(%esp)
77303afa:	e8 51 19 00 00       	call   77305450 <_HeapFree@12>
77303aff:	31 c0                	xor    %eax,%eax
77303b01:	5f                   	pop    %edi
77303b02:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77303b05:	5b                   	pop    %ebx
77303b06:	5e                   	pop    %esi
77303b07:	5f                   	pop    %edi
77303b08:	5d                   	pop    %ebp
77303b09:	c2 0c 00             	ret    $0xc
77303b0c:	8d 74 26 00          	lea    0x0(%esi),%esi

77303b10 <_GetBestInterface@8>:
77303b10:	55                   	push   %ebp
77303b11:	ba 57 00 00 00       	mov    $0x57,%edx
77303b16:	89 e5                	mov    %esp,%ebp
77303b18:	53                   	push   %ebx
77303b19:	83 ec 44             	sub    $0x44,%esp
77303b1c:	8b 5d 0c             	mov    0xc(%ebp),%ebx
77303b1f:	85 db                	test   %ebx,%ebx
77303b21:	74 1d                	je     77303b40 <_GetBestInterface@8+0x30>
77303b23:	50                   	push   %eax
77303b24:	8d 45 b8             	lea    0xffffffb8(%ebp),%eax
77303b27:	50                   	push   %eax
77303b28:	8b 45 08             	mov    0x8(%ebp),%eax
77303b2b:	6a 00                	push   $0x0
77303b2d:	50                   	push   %eax
77303b2e:	e8 fd fe ff ff       	call   77303a30 <_GetBestRoute@12>
77303b33:	89 c2                	mov    %eax,%edx
77303b35:	59                   	pop    %ecx
77303b36:	85 c0                	test   %eax,%eax
77303b38:	75 06                	jne    77303b40 <_GetBestInterface@8+0x30>
77303b3a:	8b 45 c8             	mov    0xffffffc8(%ebp),%eax
77303b3d:	89 03                	mov    %eax,(%ebx)
77303b3f:	90                   	nop    
77303b40:	89 d0                	mov    %edx,%eax
77303b42:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
77303b45:	c9                   	leave  
77303b46:	c2 08 00             	ret    $0x8
77303b49:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

77303b50 <_IpNetTableSorter>:


static int IpNetTableSorter(const void *a, const void *b)
{
77303b50:	55                   	push   %ebp
77303b51:	89 e5                	mov    %esp,%ebp
77303b53:	56                   	push   %esi
77303b54:	53                   	push   %ebx
77303b55:	8b 75 0c             	mov    0xc(%ebp),%esi
77303b58:	8b 5d 08             	mov    0x8(%ebp),%ebx
  int ret;

  if (a && b)
77303b5b:	85 db                	test   %ebx,%ebx
77303b5d:	0f 95 c2             	setne  %dl
77303b60:	85 f6                	test   %esi,%esi
77303b62:	0f 95 c0             	setne  %al
77303b65:	25 ff 00 00 00       	and    $0xff,%eax
    ret = ((PMIB_IPNETROW)a)->dwAddr - ((PMIB_IPNETROW)b)->dwAddr;
  else
    ret = 0;
77303b6a:	31 c9                	xor    %ecx,%ecx
77303b6c:	85 c2                	test   %eax,%edx
77303b6e:	74 08                	je     77303b78 <_IpNetTableSorter+0x28>
77303b70:	8b 4b 10             	mov    0x10(%ebx),%ecx
77303b73:	8b 46 10             	mov    0x10(%esi),%eax
77303b76:	29 c1                	sub    %eax,%ecx
  return ret;
}
77303b78:	89 c8                	mov    %ecx,%eax
77303b7a:	5b                   	pop    %ebx
77303b7b:	5e                   	pop    %esi
77303b7c:	5d                   	pop    %ebp
77303b7d:	c3                   	ret    
77303b7e:	89 f6                	mov    %esi,%esi

77303b80 <_GetIpNetTable@12>:


/******************************************************************
 *    GetIpNetTable (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pIpNetTable [In/Out]
 *  pdwSize [In/Out]
 *  bOrder [In]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetIpNetTable(PMIB_IPNETTABLE pIpNetTable, PULONG pdwSize, BOOL bOrder)
{
77303b80:	55                   	push   %ebp
77303b81:	89 e5                	mov    %esp,%ebp
77303b83:	57                   	push   %edi
77303b84:	56                   	push   %esi
77303b85:	53                   	push   %ebx
77303b86:	83 ec 0c             	sub    $0xc,%esp
  DWORD ret;

  TRACE("pIpNetTable %p, pdwSize %p, bOrder %ld\n", pIpNetTable, pdwSize,
   (DWORD)bOrder);
  if (!pdwSize)
    ret = ERROR_INVALID_PARAMETER;
77303b89:	be 57 00 00 00       	mov    $0x57,%esi
77303b8e:	8b 7d 0c             	mov    0xc(%ebp),%edi
77303b91:	85 ff                	test   %edi,%edi
77303b93:	74 21                	je     77303bb6 <_GetIpNetTable@12+0x36>
  else {
    DWORD numEntries = getNumArpEntries();
77303b95:	e8 26 f0 ff ff       	call   77302bc0 <_getNumArpEntries>
    ULONG size = sizeof(MIB_IPNETTABLE) + (numEntries - 1) *
     sizeof(MIB_IPNETROW);

    if (!pIpNetTable || *pdwSize < size) {
77303b9a:	8b 5d 08             	mov    0x8(%ebp),%ebx
77303b9d:	85 db                	test   %ebx,%ebx
77303b9f:	8d 04 40             	lea    (%eax,%eax,2),%eax
77303ba2:	8d 04 c5 04 00 00 00 	lea    0x4(,%eax,8),%eax
77303ba9:	74 04                	je     77303baf <_GetIpNetTable@12+0x2f>
77303bab:	39 07                	cmp    %eax,(%edi)
77303bad:	73 13                	jae    77303bc2 <_GetIpNetTable@12+0x42>
      *pdwSize = size;
77303baf:	89 07                	mov    %eax,(%edi)
      ret = ERROR_INSUFFICIENT_BUFFER;
77303bb1:	be 7a 00 00 00       	mov    $0x7a,%esi
    } 
    else {
      PMIB_IPNETTABLE table = getArpTable();

      if (table) {
        size = sizeof(MIB_IPNETTABLE) + (table->dwNumEntries - 1) *
         sizeof(MIB_IPNETROW);
        if (*pdwSize < size) {
          *pdwSize = size;
          ret = ERROR_INSUFFICIENT_BUFFER;
        }
        else {
          memcpy(pIpNetTable, table, size);
          if (bOrder)
            qsort(pIpNetTable->table, pIpNetTable->dwNumEntries,
             sizeof(MIB_IPNETROW), IpNetTableSorter);
          ret = NO_ERROR;
        }
        free(table);
      }
      else
        ret = ERROR_OUTOFMEMORY;
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}
77303bb6:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77303bb9:	89 f0                	mov    %esi,%eax
77303bbb:	5b                   	pop    %ebx
77303bbc:	5e                   	pop    %esi
77303bbd:	5f                   	pop    %edi
77303bbe:	5d                   	pop    %ebp
77303bbf:	c2 0c 00             	ret    $0xc
77303bc2:	e8 09 f0 ff ff       	call   77302bd0 <_getArpTable>
77303bc7:	be 0e 00 00 00       	mov    $0xe,%esi
77303bcc:	89 c3                	mov    %eax,%ebx
77303bce:	85 c0                	test   %eax,%eax
77303bd0:	74 e4                	je     77303bb6 <_GetIpNetTable@12+0x36>
77303bd2:	8b 00                	mov    (%eax),%eax
77303bd4:	8d 04 40             	lea    (%eax,%eax,2),%eax
77303bd7:	8d 04 c5 04 00 00 00 	lea    0x4(,%eax,8),%eax
77303bde:	39 07                	cmp    %eax,(%edi)
77303be0:	73 1e                	jae    77303c00 <_GetIpNetTable@12+0x80>
77303be2:	89 07                	mov    %eax,(%edi)
77303be4:	66 be 7a 00          	mov    $0x7a,%si
77303be8:	83 ec 0c             	sub    $0xc,%esp
77303beb:	53                   	push   %ebx
77303bec:	e8 2f 43 00 00       	call   77307f20 <_free>
77303bf1:	89 f0                	mov    %esi,%eax
77303bf3:	83 c4 10             	add    $0x10,%esp
77303bf6:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77303bf9:	5b                   	pop    %ebx
77303bfa:	5e                   	pop    %esi
77303bfb:	5f                   	pop    %edi
77303bfc:	5d                   	pop    %ebp
77303bfd:	c2 0c 00             	ret    $0xc
77303c00:	fc                   	cld    
77303c01:	89 c1                	mov    %eax,%ecx
77303c03:	8b 7d 08             	mov    0x8(%ebp),%edi
77303c06:	c1 e9 02             	shr    $0x2,%ecx
77303c09:	89 de                	mov    %ebx,%esi
77303c0b:	f3 a5                	repz movsl %ds:(%esi),%es:(%edi)
77303c0d:	8b 4d 10             	mov    0x10(%ebp),%ecx
77303c10:	85 c9                	test   %ecx,%ecx
77303c12:	75 04                	jne    77303c18 <_GetIpNetTable@12+0x98>
77303c14:	31 f6                	xor    %esi,%esi
77303c16:	eb d0                	jmp    77303be8 <_GetIpNetTable@12+0x68>
77303c18:	68 50 3b 30 77       	push   $0x77303b50
77303c1d:	6a 18                	push   $0x18
77303c1f:	8b 45 08             	mov    0x8(%ebp),%eax
77303c22:	31 f6                	xor    %esi,%esi
77303c24:	8b 10                	mov    (%eax),%edx
77303c26:	83 c0 04             	add    $0x4,%eax
77303c29:	52                   	push   %edx
77303c2a:	50                   	push   %eax
77303c2b:	e8 90 3d 00 00       	call   773079c0 <_qsort>
77303c30:	83 c4 10             	add    $0x10,%esp
77303c33:	eb b3                	jmp    77303be8 <_GetIpNetTable@12+0x68>
77303c35:	8d 74 26 00          	lea    0x0(%esi),%esi
77303c39:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77303c40 <_AllocateAndGetIpNetTableFromStack@16>:
77303c40:	55                   	push   %ebp
77303c41:	b8 57 00 00 00       	mov    $0x57,%eax
77303c46:	89 e5                	mov    %esp,%ebp
77303c48:	57                   	push   %edi
77303c49:	56                   	push   %esi
77303c4a:	53                   	push   %ebx
77303c4b:	83 ec 0c             	sub    $0xc,%esp
77303c4e:	8b 5d 08             	mov    0x8(%ebp),%ebx
77303c51:	8b 7d 0c             	mov    0xc(%ebp),%edi
77303c54:	85 db                	test   %ebx,%ebx
77303c56:	74 1b                	je     77303c73 <_AllocateAndGetIpNetTableFromStack@16+0x33>
77303c58:	56                   	push   %esi
77303c59:	8d 75 f0             	lea    0xfffffff0(%ebp),%esi
77303c5c:	57                   	push   %edi
77303c5d:	56                   	push   %esi
77303c5e:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
77303c65:	8b 0b                	mov    (%ebx),%ecx
77303c67:	51                   	push   %ecx
77303c68:	e8 13 ff ff ff       	call   77303b80 <_GetIpNetTable@12>
77303c6d:	5a                   	pop    %edx
77303c6e:	83 f8 7a             	cmp    $0x7a,%eax
77303c71:	74 0a                	je     77303c7d <_AllocateAndGetIpNetTableFromStack@16+0x3d>
77303c73:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77303c76:	5b                   	pop    %ebx
77303c77:	5e                   	pop    %esi
77303c78:	5f                   	pop    %edi
77303c79:	5d                   	pop    %ebp
77303c7a:	c2 10 00             	ret    $0x10
77303c7d:	50                   	push   %eax
77303c7e:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
77303c81:	50                   	push   %eax
77303c82:	8b 45 14             	mov    0x14(%ebp),%eax
77303c85:	50                   	push   %eax
77303c86:	8b 45 10             	mov    0x10(%ebp),%eax
77303c89:	50                   	push   %eax
77303c8a:	e8 b1 17 00 00       	call   77305440 <_HeapAlloc@12>
77303c8f:	89 03                	mov    %eax,(%ebx)
77303c91:	57                   	push   %edi
77303c92:	56                   	push   %esi
77303c93:	50                   	push   %eax
77303c94:	e8 e7 fe ff ff       	call   77303b80 <_GetIpNetTable@12>
77303c99:	5e                   	pop    %esi
77303c9a:	eb d7                	jmp    77303c73 <_AllocateAndGetIpNetTableFromStack@16+0x33>
77303c9c:	8d 74 26 00          	lea    0x0(%esi),%esi

77303ca0 <_GetIpStatisticsEx@8>:


/******************************************************************
 *    GetIpStatistics (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pStats [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetIpStatistics(PMIB_IPSTATS pStats)
{
    return GetIpStatisticsEx(pStats, PF_INET);
}

/******************************************************************
 *    GetIpStatisticsEx (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pStats [In/Out]
 *  dwFamily [In]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetIpStatisticsEx(PMIB_IPSTATS pStats, DWORD dwFamily)
{
77303ca0:	55                   	push   %ebp
77303ca1:	89 e5                	mov    %esp,%ebp
77303ca3:	83 ec 10             	sub    $0x10,%esp
  DWORD ret;

  TRACE("pStats %p\n", pStats);
  ret = getIPStats(pStats, dwFamily);
77303ca6:	8b 45 0c             	mov    0xc(%ebp),%eax
77303ca9:	50                   	push   %eax
77303caa:	8b 45 08             	mov    0x8(%ebp),%eax
77303cad:	50                   	push   %eax
77303cae:	e8 ad eb ff ff       	call   77302860 <_getIPStats>
  TRACE("returning %ld\n", ret);
  return ret;
}
77303cb3:	c9                   	leave  
77303cb4:	c2 08 00             	ret    $0x8
77303cb7:	89 f6                	mov    %esi,%esi
77303cb9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77303cc0 <_GetIpStatistics@4>:
77303cc0:	55                   	push   %ebp
77303cc1:	89 e5                	mov    %esp,%ebp
77303cc3:	83 ec 10             	sub    $0x10,%esp
77303cc6:	8b 45 08             	mov    0x8(%ebp),%eax
77303cc9:	6a 02                	push   $0x2
77303ccb:	50                   	push   %eax
77303ccc:	e8 cf ff ff ff       	call   77303ca0 <_GetIpStatisticsEx@8>
77303cd1:	c9                   	leave  
77303cd2:	c2 04 00             	ret    $0x4
77303cd5:	8d 74 26 00          	lea    0x0(%esi),%esi
77303cd9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77303ce0 <_GetNetworkParams@8>:

/******************************************************************
 *    GetNetworkParams (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pFixedInfo [In/Out]
 *  pOutBufLen [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetNetworkParams(PFIXED_INFO pFixedInfo, PULONG pOutBufLen)
{
77303ce0:	55                   	push   %ebp
  DWORD ret, size;
  LONG regReturn;
  HKEY hKey;
  PIPHLP_RES_INFO resInfo;

  TRACE("pFixedInfo %p, pOutBufLen %p\n", pFixedInfo, pOutBufLen);
  if (!pOutBufLen)
    return ERROR_INVALID_PARAMETER;
77303ce1:	b8 57 00 00 00       	mov    $0x57,%eax
77303ce6:	89 e5                	mov    %esp,%ebp
77303ce8:	57                   	push   %edi
77303ce9:	56                   	push   %esi
77303cea:	53                   	push   %ebx
77303ceb:	83 ec 0c             	sub    $0xc,%esp
77303cee:	8b 5d 0c             	mov    0xc(%ebp),%ebx
77303cf1:	85 db                	test   %ebx,%ebx
77303cf3:	74 44                	je     77303d39 <_GetNetworkParams@8+0x59>

  resInfo = getResInfo();
77303cf5:	e8 c6 0d 00 00       	call   77304ac0 <_getResInfo>
77303cfa:	89 c6                	mov    %eax,%esi
  if (!resInfo) 
    return ERROR_OUTOFMEMORY;
77303cfc:	b8 0e 00 00 00       	mov    $0xe,%eax
77303d01:	85 f6                	test   %esi,%esi
77303d03:	74 34                	je     77303d39 <_GetNetworkParams@8+0x59>

  size = sizeof(FIXED_INFO) + (resInfo->riCount > 0 ? (resInfo->riCount  - 1) *
77303d05:	8b 06                	mov    (%esi),%eax
77303d07:	85 c0                	test   %eax,%eax
77303d09:	8d 14 80             	lea    (%eax,%eax,4),%edx
77303d0c:	8d 14 d5 20 02 00 00 	lea    0x220(,%edx,8),%edx
77303d13:	74 2e                	je     77303d43 <_GetNetworkParams@8+0x63>
   sizeof(IP_ADDR_STRING) : 0);
  if (!pFixedInfo || *pOutBufLen < size) {
77303d15:	8b 45 08             	mov    0x8(%ebp),%eax
77303d18:	89 55 f0             	mov    %edx,0xfffffff0(%ebp)
77303d1b:	85 c0                	test   %eax,%eax
77303d1d:	0f 84 88 01 00 00    	je     77303eab <_GetNetworkParams@8+0x1cb>
77303d23:	89 d0                	mov    %edx,%eax
77303d25:	39 13                	cmp    %edx,(%ebx)
77303d27:	73 27                	jae    77303d50 <_GetNetworkParams@8+0x70>
    *pOutBufLen = size;
    disposeResInfo( resInfo );
77303d29:	83 ec 0c             	sub    $0xc,%esp
77303d2c:	89 03                	mov    %eax,(%ebx)
77303d2e:	56                   	push   %esi
77303d2f:	e8 6c 0f 00 00       	call   77304ca0 <_disposeResInfo>
    return ERROR_BUFFER_OVERFLOW;
77303d34:	b8 6f 00 00 00       	mov    $0x6f,%eax
  }

  memset(pFixedInfo, 0, size);
  size = sizeof(pFixedInfo->HostName);
  GetComputerNameExA(ComputerNameDnsHostname, pFixedInfo->HostName, &size);
  size = sizeof(pFixedInfo->DomainName);
  GetComputerNameExA(ComputerNameDnsDomain, pFixedInfo->DomainName, &size);

  TRACE("GetComputerNameExA: %s\n", pFixedInfo->DomainName);

  if (resInfo->riCount > 0) {
    PIP_ADDR_STRING ptr;
    int i;

    for (i = 0, ptr = &pFixedInfo->DnsServerList; i < resInfo->riCount && ptr;
     i++, ptr = ptr->Next) {
        struct sockaddr_in *addr_v4 = 
            (struct sockaddr_in *)&resInfo->riAddressList[i];
        toIPAddressString
            (addr_v4->sin_addr.s_addr,
             ptr->IpAddress.String);
      if (i == resInfo->riCount - 1)
        ptr->Next = NULL;
      else if (i == 0)
        ptr->Next = (PIP_ADDR_STRING)((LPBYTE)pFixedInfo + sizeof(FIXED_INFO));
      else
        ptr->Next = (PIP_ADDR_STRING)((PBYTE)ptr + sizeof(IP_ADDR_STRING));
    }
  }
  pFixedInfo->NodeType = HYBRID_NODETYPE;
  regReturn = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
   "SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP", 0, KEY_READ, &hKey);
  if (regReturn != ERROR_SUCCESS)
    regReturn = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
     "SYSTEM\\CurrentControlSet\\Services\\NetBT\\Parameters", 0, KEY_READ,
     &hKey);
  if (regReturn == ERROR_SUCCESS)
  {
    DWORD size = sizeof(pFixedInfo->ScopeId);

    RegQueryValueExA(hKey, "ScopeID", NULL, NULL, pFixedInfo->ScopeId, &size);
    RegCloseKey(hKey);
  }

  disposeResInfo( resInfo );
  /* FIXME: can check whether routing's enabled in /proc/sys/net/ipv4/ip_forward
     I suppose could also check for a listener on port 53 to set EnableDns */
  ret = NO_ERROR;
  TRACE("returning %ld\n", ret);

  return ret;
}
77303d39:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77303d3c:	5b                   	pop    %ebx
77303d3d:	5e                   	pop    %esi
77303d3e:	5f                   	pop    %edi
77303d3f:	5d                   	pop    %ebp
77303d40:	c2 08 00             	ret    $0x8
77303d43:	ba 48 02 00 00       	mov    $0x248,%edx
77303d48:	eb cb                	jmp    77303d15 <_GetNetworkParams@8+0x35>
77303d4a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77303d50:	fc                   	cld    
77303d51:	89 d1                	mov    %edx,%ecx
77303d53:	8b 7d 08             	mov    0x8(%ebp),%edi
77303d56:	31 c0                	xor    %eax,%eax
77303d58:	8d 5d f0             	lea    0xfffffff0(%ebp),%ebx
77303d5b:	c1 e9 02             	shr    $0x2,%ecx
77303d5e:	f3 ab                	repz stos %eax,%es:(%edi)
77303d60:	c7 45 f0 84 00 00 00 	movl   $0x84,0xfffffff0(%ebp)
77303d67:	50                   	push   %eax
77303d68:	53                   	push   %ebx
77303d69:	8b 7d 08             	mov    0x8(%ebp),%edi
77303d6c:	57                   	push   %edi
77303d6d:	6a 01                	push   $0x1
77303d6f:	e8 fc 16 00 00       	call   77305470 <_GetComputerNameExA@12>
77303d74:	c7 45 f0 84 00 00 00 	movl   $0x84,0xfffffff0(%ebp)
77303d7b:	53                   	push   %ebx
77303d7c:	8b 45 08             	mov    0x8(%ebp),%eax
77303d7f:	05 84 00 00 00       	add    $0x84,%eax
77303d84:	50                   	push   %eax
77303d85:	6a 02                	push   $0x2
77303d87:	e8 e4 16 00 00       	call   77305470 <_GetComputerNameExA@12>
77303d8c:	8b 06                	mov    (%esi),%eax
77303d8e:	5b                   	pop    %ebx
77303d8f:	85 c0                	test   %eax,%eax
77303d91:	74 6d                	je     77303e00 <_GetNetworkParams@8+0x120>
77303d93:	31 ff                	xor    %edi,%edi
77303d95:	8b 5d 08             	mov    0x8(%ebp),%ebx
77303d98:	39 c7                	cmp    %eax,%edi
77303d9a:	0f 92 c2             	setb   %dl
77303d9d:	81 c3 0c 01 00 00    	add    $0x10c,%ebx
77303da3:	0f 95 c0             	setne  %al
77303da6:	25 ff 00 00 00       	and    $0xff,%eax
77303dab:	85 c2                	test   %eax,%edx
77303dad:	74 51                	je     77303e00 <_GetNetworkParams@8+0x120>
77303daf:	90                   	nop    
77303db0:	89 f8                	mov    %edi,%eax
77303db2:	8b 4e 04             	mov    0x4(%esi),%ecx
77303db5:	c1 e0 04             	shl    $0x4,%eax
77303db8:	01 c8                	add    %ecx,%eax
77303dba:	52                   	push   %edx
77303dbb:	52                   	push   %edx
77303dbc:	8d 53 04             	lea    0x4(%ebx),%edx
77303dbf:	52                   	push   %edx
77303dc0:	8b 48 04             	mov    0x4(%eax),%ecx
77303dc3:	51                   	push   %ecx
77303dc4:	e8 77 e2 ff ff       	call   77302040 <_toIPAddressString>
77303dc9:	8b 16                	mov    (%esi),%edx
77303dcb:	83 c4 10             	add    $0x10,%esp
77303dce:	8d 42 ff             	lea    0xffffffff(%edx),%eax
77303dd1:	39 c7                	cmp    %eax,%edi
77303dd3:	0f 84 c7 00 00 00    	je     77303ea0 <_GetNetworkParams@8+0x1c0>
77303dd9:	8d 43 28             	lea    0x28(%ebx),%eax
77303ddc:	85 ff                	test   %edi,%edi
77303dde:	75 08                	jne    77303de8 <_GetNetworkParams@8+0x108>
77303de0:	8b 45 08             	mov    0x8(%ebp),%eax
77303de3:	05 48 02 00 00       	add    $0x248,%eax
77303de8:	89 03                	mov    %eax,(%ebx)
77303dea:	47                   	inc    %edi
77303deb:	8b 1b                	mov    (%ebx),%ebx
77303ded:	39 d7                	cmp    %edx,%edi
77303def:	0f 92 c2             	setb   %dl
77303df2:	85 db                	test   %ebx,%ebx
77303df4:	0f 95 c0             	setne  %al
77303df7:	25 ff 00 00 00       	and    $0xff,%eax
77303dfc:	85 c2                	test   %eax,%edx
77303dfe:	75 b0                	jne    77303db0 <_GetNetworkParams@8+0xd0>
77303e00:	8b 45 08             	mov    0x8(%ebp),%eax
77303e03:	83 ec 0c             	sub    $0xc,%esp
77303e06:	8d 5d ec             	lea    0xffffffec(%ebp),%ebx
77303e09:	c7 80 34 01 00 00 08 	movl   $0x8,0x134(%eax)
77303e10:	00 00 00 
77303e13:	53                   	push   %ebx
77303e14:	68 19 00 02 00       	push   $0x20019
77303e19:	6a 00                	push   $0x0
77303e1b:	68 e8 a1 30 77       	push   $0x7730a1e8
77303e20:	68 02 00 00 80       	push   $0x80000002
77303e25:	e8 86 15 00 00       	call   773053b0 <_RegOpenKeyExA@20>
77303e2a:	83 c4 0c             	add    $0xc,%esp
77303e2d:	85 c0                	test   %eax,%eax
77303e2f:	74 21                	je     77303e52 <_GetNetworkParams@8+0x172>
77303e31:	83 ec 0c             	sub    $0xc,%esp
77303e34:	53                   	push   %ebx
77303e35:	68 19 00 02 00       	push   $0x20019
77303e3a:	6a 00                	push   $0x0
77303e3c:	68 14 a2 30 77       	push   $0x7730a214
77303e41:	68 02 00 00 80       	push   $0x80000002
77303e46:	e8 65 15 00 00       	call   773053b0 <_RegOpenKeyExA@20>
77303e4b:	83 c4 0c             	add    $0xc,%esp
77303e4e:	85 c0                	test   %eax,%eax
77303e50:	75 35                	jne    77303e87 <_GetNetworkParams@8+0x1a7>
77303e52:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
77303e55:	c7 45 e8 04 01 00 00 	movl   $0x104,0xffffffe8(%ebp)
77303e5c:	52                   	push   %edx
77303e5d:	52                   	push   %edx
77303e5e:	50                   	push   %eax
77303e5f:	8b 45 08             	mov    0x8(%ebp),%eax
77303e62:	05 38 01 00 00       	add    $0x138,%eax
77303e67:	50                   	push   %eax
77303e68:	6a 00                	push   $0x0
77303e6a:	6a 00                	push   $0x0
77303e6c:	68 47 a2 30 77       	push   $0x7730a247
77303e71:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
77303e74:	50                   	push   %eax
77303e75:	e8 46 15 00 00       	call   773053c0 <_RegQueryValueExA@24>
77303e7a:	50                   	push   %eax
77303e7b:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
77303e7e:	50                   	push   %eax
77303e7f:	e8 4c 15 00 00       	call   773053d0 <_RegCloseKey@4>
77303e84:	83 c4 0c             	add    $0xc,%esp
77303e87:	83 ec 0c             	sub    $0xc,%esp
77303e8a:	56                   	push   %esi
77303e8b:	e8 10 0e 00 00       	call   77304ca0 <_disposeResInfo>
77303e90:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77303e93:	31 c0                	xor    %eax,%eax
77303e95:	5b                   	pop    %ebx
77303e96:	5e                   	pop    %esi
77303e97:	5f                   	pop    %edi
77303e98:	5d                   	pop    %ebp
77303e99:	c2 08 00             	ret    $0x8
77303e9c:	8d 74 26 00          	lea    0x0(%esi),%esi
77303ea0:	c7 03 00 00 00 00    	movl   $0x0,(%ebx)
77303ea6:	e9 3f ff ff ff       	jmp    77303dea <_GetNetworkParams@8+0x10a>
77303eab:	89 d0                	mov    %edx,%eax
77303ead:	e9 77 fe ff ff       	jmp    77303d29 <_GetNetworkParams@8+0x49>
77303eb2:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
77303eb9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77303ec0 <_GetNumberOfInterfaces@4>:


/******************************************************************
 *    GetNumberOfInterfaces (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pdwNumIf [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetNumberOfInterfaces(PDWORD pdwNumIf)
{
77303ec0:	55                   	push   %ebp
77303ec1:	89 e5                	mov    %esp,%ebp
77303ec3:	53                   	push   %ebx
77303ec4:	51                   	push   %ecx
  DWORD ret;

  TRACE("pdwNumIf %p\n", pdwNumIf);
  if (!pdwNumIf)
    ret = ERROR_INVALID_PARAMETER;
77303ec5:	b8 57 00 00 00       	mov    $0x57,%eax
77303eca:	8b 5d 08             	mov    0x8(%ebp),%ebx
77303ecd:	85 db                	test   %ebx,%ebx
77303ecf:	74 09                	je     77303eda <_GetNumberOfInterfaces@4+0x1a>
  else {
    *pdwNumIf = getNumInterfaces();
77303ed1:	e8 ea d8 ff ff       	call   773017c0 <_getNumInterfaces>
77303ed6:	89 03                	mov    %eax,(%ebx)
    ret = NO_ERROR;
77303ed8:	31 c0                	xor    %eax,%eax
  }
  TRACE("returning %ld\n", ret);
  return ret;
}
77303eda:	5a                   	pop    %edx
77303edb:	5b                   	pop    %ebx
77303edc:	5d                   	pop    %ebp
77303edd:	c2 04 00             	ret    $0x4

77303ee0 <_GetPerAdapterInfo@12>:


/******************************************************************
 *    GetPerAdapterInfo (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  IfIndex [In]
 *  pPerAdapterInfo [In/Out]
 *  pOutBufLen [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetPerAdapterInfo(ULONG IfIndex, PIP_PER_ADAPTER_INFO pPerAdapterInfo, PULONG pOutBufLen)
{
77303ee0:	55                   	push   %ebp
77303ee1:	89 e5                	mov    %esp,%ebp
77303ee3:	50                   	push   %eax
77303ee4:	50                   	push   %eax
  TRACE("IfIndex %ld, pPerAdapterInfo %p, pOutBufLen %p\n", IfIndex,
   pPerAdapterInfo, pOutBufLen);
  FIXME(":stub\n");
77303ee5:	68 4f a2 30 77       	push   $0x7730a24f
77303eea:	68 a7 05 00 00       	push   $0x5a7
77303eef:	68 fd a0 30 77       	push   $0x7730a0fd
77303ef4:	68 0d a1 30 77       	push   $0x7730a10d
77303ef9:	e8 82 3a 00 00       	call   77307980 <_DbgPrint>
77303efe:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77303f05:	e8 76 3a 00 00       	call   77307980 <_DbgPrint>
  /* marking Win2K+ functions not supported */
  return ERROR_NOT_SUPPORTED;
}
77303f0a:	b8 32 00 00 00       	mov    $0x32,%eax
77303f0f:	c9                   	leave  
77303f10:	c2 0c 00             	ret    $0xc
77303f13:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77303f19:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77303f20 <_GetRTTAndHopCount@16>:


/******************************************************************
 *    GetRTTAndHopCount (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  DestIpAddress [In]
 *  HopCount [In/Out]
 *  MaxHops [In]
 *  RTT [In/Out]
 *
 * RETURNS
 *
 *  BOOL
 *
 */
BOOL WINAPI GetRTTAndHopCount(IPAddr DestIpAddress, PULONG HopCount, ULONG MaxHops, PULONG RTT)
{
77303f20:	55                   	push   %ebp
77303f21:	89 e5                	mov    %esp,%ebp
77303f23:	50                   	push   %eax
77303f24:	50                   	push   %eax
  TRACE("DestIpAddress 0x%08lx, HopCount %p, MaxHops %ld, RTT %p\n",
   DestIpAddress, HopCount, MaxHops, RTT);
  FIXME(":stub\n");
77303f25:	68 61 a2 30 77       	push   $0x7730a261
77303f2a:	68 c1 05 00 00       	push   $0x5c1
77303f2f:	68 fd a0 30 77       	push   $0x7730a0fd
77303f34:	68 0d a1 30 77       	push   $0x7730a10d
77303f39:	e8 42 3a 00 00       	call   77307980 <_DbgPrint>
77303f3e:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77303f45:	e8 36 3a 00 00       	call   77307980 <_DbgPrint>
  return (BOOL) 0;
}
77303f4a:	31 c0                	xor    %eax,%eax
77303f4c:	c9                   	leave  
77303f4d:	c2 10 00             	ret    $0x10

77303f50 <_GetTcpStatisticsEx@8>:


/******************************************************************
 *    GetTcpStatisticsEx (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pStats [In/Out]
 *  dwFamily [In]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetTcpStatisticsEx(PMIB_TCPSTATS pStats, DWORD dwFamily)
{
77303f50:	55                   	push   %ebp
77303f51:	89 e5                	mov    %esp,%ebp
77303f53:	83 ec 10             	sub    $0x10,%esp
  DWORD ret;

  TRACE("pStats %p\n", pStats);
  ret = getTCPStats(pStats, dwFamily);
77303f56:	8b 45 0c             	mov    0xc(%ebp),%eax
77303f59:	50                   	push   %eax
77303f5a:	8b 45 08             	mov    0x8(%ebp),%eax
77303f5d:	50                   	push   %eax
77303f5e:	e8 0d e9 ff ff       	call   77302870 <_getTCPStats>
  TRACE("returning %ld\n", ret);
  return ret;
}
77303f63:	c9                   	leave  
77303f64:	c2 08 00             	ret    $0x8
77303f67:	89 f6                	mov    %esi,%esi
77303f69:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77303f70 <_GetTcpStatistics@4>:

/******************************************************************
 *    GetTcpStatistics (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pStats [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetTcpStatistics(PMIB_TCPSTATS pStats)
{
77303f70:	55                   	push   %ebp
77303f71:	89 e5                	mov    %esp,%ebp
77303f73:	83 ec 10             	sub    $0x10,%esp
    return GetTcpStatisticsEx(pStats, PF_INET);
77303f76:	8b 45 08             	mov    0x8(%ebp),%eax
77303f79:	6a 02                	push   $0x2
77303f7b:	50                   	push   %eax
77303f7c:	e8 cf ff ff ff       	call   77303f50 <_GetTcpStatisticsEx@8>
}
77303f81:	c9                   	leave  
77303f82:	c2 04 00             	ret    $0x4
77303f85:	8d 74 26 00          	lea    0x0(%esi),%esi
77303f89:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77303f90 <_TcpTableSorter>:


static int TcpTableSorter(const void *a, const void *b)
{
77303f90:	55                   	push   %ebp
77303f91:	89 e5                	mov    %esp,%ebp
77303f93:	56                   	push   %esi
77303f94:	53                   	push   %ebx
77303f95:	8b 75 08             	mov    0x8(%ebp),%esi
77303f98:	8b 5d 0c             	mov    0xc(%ebp),%ebx
  int ret;

  if (a && b) {
77303f9b:	85 f6                	test   %esi,%esi
77303f9d:	0f 95 c2             	setne  %dl
77303fa0:	85 db                	test   %ebx,%ebx
77303fa2:	0f 95 c0             	setne  %al
77303fa5:	25 ff 00 00 00       	and    $0xff,%eax
    PMIB_TCPROW rowA = (PMIB_TCPROW)a, rowB = (PMIB_TCPROW)b;

    ret = rowA->dwLocalAddr - rowB->dwLocalAddr;
    if (ret == 0) {
      ret = rowA->dwLocalPort - rowB->dwLocalPort;
      if (ret == 0) {
        ret = rowA->dwRemoteAddr - rowB->dwRemoteAddr;
        if (ret == 0)
          ret = rowA->dwRemotePort - rowB->dwRemotePort;
      }
    }
  }
  else
    ret = 0;
77303faa:	31 c9                	xor    %ecx,%ecx
77303fac:	85 c2                	test   %eax,%edx
77303fae:	74 26                	je     77303fd6 <_TcpTableSorter+0x46>
77303fb0:	8b 46 04             	mov    0x4(%esi),%eax
77303fb3:	89 c1                	mov    %eax,%ecx
77303fb5:	2b 4b 04             	sub    0x4(%ebx),%ecx
77303fb8:	75 1c                	jne    77303fd6 <_TcpTableSorter+0x46>
77303fba:	8b 46 08             	mov    0x8(%esi),%eax
77303fbd:	89 c1                	mov    %eax,%ecx
77303fbf:	2b 4b 08             	sub    0x8(%ebx),%ecx
77303fc2:	75 12                	jne    77303fd6 <_TcpTableSorter+0x46>
77303fc4:	8b 46 0c             	mov    0xc(%esi),%eax
77303fc7:	89 c1                	mov    %eax,%ecx
77303fc9:	2b 4b 0c             	sub    0xc(%ebx),%ecx
77303fcc:	75 08                	jne    77303fd6 <_TcpTableSorter+0x46>
77303fce:	8b 4e 10             	mov    0x10(%esi),%ecx
77303fd1:	8b 43 10             	mov    0x10(%ebx),%eax
77303fd4:	29 c1                	sub    %eax,%ecx
  return ret;
}
77303fd6:	89 c8                	mov    %ecx,%eax
77303fd8:	5b                   	pop    %ebx
77303fd9:	5e                   	pop    %esi
77303fda:	5d                   	pop    %ebp
77303fdb:	c3                   	ret    
77303fdc:	8d 74 26 00          	lea    0x0(%esi),%esi

77303fe0 <_GetTcpTable@12>:


/******************************************************************
 *    GetTcpTable (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pTcpTable [In/Out]
 *  pdwSize [In/Out]
 *  bOrder [In]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetTcpTable(PMIB_TCPTABLE pTcpTable, PDWORD pdwSize, BOOL bOrder)
{
77303fe0:	55                   	push   %ebp
77303fe1:	89 e5                	mov    %esp,%ebp
77303fe3:	57                   	push   %edi
77303fe4:	56                   	push   %esi
77303fe5:	53                   	push   %ebx
77303fe6:	83 ec 0c             	sub    $0xc,%esp
  DWORD ret;

  TRACE("pTcpTable %p, pdwSize %p, bOrder %ld\n", pTcpTable, pdwSize,
   (DWORD)bOrder);
  if (!pdwSize)
    ret = ERROR_INVALID_PARAMETER;
77303fe9:	be 57 00 00 00       	mov    $0x57,%esi
77303fee:	8b 7d 0c             	mov    0xc(%ebp),%edi
77303ff1:	85 ff                	test   %edi,%edi
77303ff3:	74 21                	je     77304016 <_GetTcpTable@12+0x36>
  else {
    DWORD numEntries = getNumTcpEntries();
77303ff5:	e8 46 ed ff ff       	call   77302d40 <_getNumTcpEntries>
    ULONG size = sizeof(MIB_TCPTABLE) + (numEntries - 1) * sizeof(MIB_TCPROW);

    if (!pTcpTable || *pdwSize < size) {
77303ffa:	8b 5d 08             	mov    0x8(%ebp),%ebx
77303ffd:	85 db                	test   %ebx,%ebx
77303fff:	8d 04 80             	lea    (%eax,%eax,4),%eax
77304002:	8d 04 85 04 00 00 00 	lea    0x4(,%eax,4),%eax
77304009:	74 04                	je     7730400f <_GetTcpTable@12+0x2f>
7730400b:	39 07                	cmp    %eax,(%edi)
7730400d:	73 13                	jae    77304022 <_GetTcpTable@12+0x42>
      *pdwSize = size;
7730400f:	89 07                	mov    %eax,(%edi)
      ret = ERROR_INSUFFICIENT_BUFFER;
77304011:	be 7a 00 00 00       	mov    $0x7a,%esi
    }
    else {
      PMIB_TCPTABLE table = getTcpTable();

      if (table) {
        size = sizeof(MIB_TCPTABLE) + (table->dwNumEntries - 1) *
         sizeof(MIB_TCPROW);
        if (*pdwSize < size) {
          *pdwSize = size;
          ret = ERROR_INSUFFICIENT_BUFFER;
        }
        else {
          memcpy(pTcpTable, table, size);
          if (bOrder)
            qsort(pTcpTable->table, pTcpTable->dwNumEntries,
             sizeof(MIB_TCPROW), TcpTableSorter);
          ret = NO_ERROR;
        }
        free(table);
      }
      else
        ret = ERROR_OUTOFMEMORY;
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}
77304016:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77304019:	89 f0                	mov    %esi,%eax
7730401b:	5b                   	pop    %ebx
7730401c:	5e                   	pop    %esi
7730401d:	5f                   	pop    %edi
7730401e:	5d                   	pop    %ebp
7730401f:	c2 0c 00             	ret    $0xc
77304022:	e8 29 ed ff ff       	call   77302d50 <_getTcpTable>
77304027:	be 0e 00 00 00       	mov    $0xe,%esi
7730402c:	89 c3                	mov    %eax,%ebx
7730402e:	85 c0                	test   %eax,%eax
77304030:	74 e4                	je     77304016 <_GetTcpTable@12+0x36>
77304032:	8b 00                	mov    (%eax),%eax
77304034:	8d 04 80             	lea    (%eax,%eax,4),%eax
77304037:	8d 04 85 04 00 00 00 	lea    0x4(,%eax,4),%eax
7730403e:	39 07                	cmp    %eax,(%edi)
77304040:	73 1e                	jae    77304060 <_GetTcpTable@12+0x80>
77304042:	89 07                	mov    %eax,(%edi)
77304044:	66 be 7a 00          	mov    $0x7a,%si
77304048:	83 ec 0c             	sub    $0xc,%esp
7730404b:	53                   	push   %ebx
7730404c:	e8 cf 3e 00 00       	call   77307f20 <_free>
77304051:	89 f0                	mov    %esi,%eax
77304053:	83 c4 10             	add    $0x10,%esp
77304056:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77304059:	5b                   	pop    %ebx
7730405a:	5e                   	pop    %esi
7730405b:	5f                   	pop    %edi
7730405c:	5d                   	pop    %ebp
7730405d:	c2 0c 00             	ret    $0xc
77304060:	fc                   	cld    
77304061:	89 c1                	mov    %eax,%ecx
77304063:	8b 7d 08             	mov    0x8(%ebp),%edi
77304066:	c1 e9 02             	shr    $0x2,%ecx
77304069:	89 de                	mov    %ebx,%esi
7730406b:	f3 a5                	repz movsl %ds:(%esi),%es:(%edi)
7730406d:	8b 4d 10             	mov    0x10(%ebp),%ecx
77304070:	85 c9                	test   %ecx,%ecx
77304072:	75 04                	jne    77304078 <_GetTcpTable@12+0x98>
77304074:	31 f6                	xor    %esi,%esi
77304076:	eb d0                	jmp    77304048 <_GetTcpTable@12+0x68>
77304078:	68 90 3f 30 77       	push   $0x77303f90
7730407d:	6a 14                	push   $0x14
7730407f:	8b 45 08             	mov    0x8(%ebp),%eax
77304082:	31 f6                	xor    %esi,%esi
77304084:	8b 10                	mov    (%eax),%edx
77304086:	83 c0 04             	add    $0x4,%eax
77304089:	52                   	push   %edx
7730408a:	50                   	push   %eax
7730408b:	e8 30 39 00 00       	call   773079c0 <_qsort>
77304090:	83 c4 10             	add    $0x10,%esp
77304093:	eb b3                	jmp    77304048 <_GetTcpTable@12+0x68>
77304095:	8d 74 26 00          	lea    0x0(%esi),%esi
77304099:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

773040a0 <_AllocateAndGetTcpTableFromStack@16>:
773040a0:	55                   	push   %ebp
773040a1:	b8 57 00 00 00       	mov    $0x57,%eax
773040a6:	89 e5                	mov    %esp,%ebp
773040a8:	57                   	push   %edi
773040a9:	56                   	push   %esi
773040aa:	53                   	push   %ebx
773040ab:	83 ec 0c             	sub    $0xc,%esp
773040ae:	8b 5d 08             	mov    0x8(%ebp),%ebx
773040b1:	8b 7d 0c             	mov    0xc(%ebp),%edi
773040b4:	85 db                	test   %ebx,%ebx
773040b6:	74 1b                	je     773040d3 <_AllocateAndGetTcpTableFromStack@16+0x33>
773040b8:	56                   	push   %esi
773040b9:	8d 75 f0             	lea    0xfffffff0(%ebp),%esi
773040bc:	57                   	push   %edi
773040bd:	56                   	push   %esi
773040be:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
773040c5:	8b 0b                	mov    (%ebx),%ecx
773040c7:	51                   	push   %ecx
773040c8:	e8 13 ff ff ff       	call   77303fe0 <_GetTcpTable@12>
773040cd:	5a                   	pop    %edx
773040ce:	83 f8 7a             	cmp    $0x7a,%eax
773040d1:	74 0a                	je     773040dd <_AllocateAndGetTcpTableFromStack@16+0x3d>
773040d3:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773040d6:	5b                   	pop    %ebx
773040d7:	5e                   	pop    %esi
773040d8:	5f                   	pop    %edi
773040d9:	5d                   	pop    %ebp
773040da:	c2 10 00             	ret    $0x10
773040dd:	50                   	push   %eax
773040de:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
773040e1:	50                   	push   %eax
773040e2:	8b 45 14             	mov    0x14(%ebp),%eax
773040e5:	50                   	push   %eax
773040e6:	8b 45 10             	mov    0x10(%ebp),%eax
773040e9:	50                   	push   %eax
773040ea:	e8 51 13 00 00       	call   77305440 <_HeapAlloc@12>
773040ef:	89 03                	mov    %eax,(%ebx)
773040f1:	57                   	push   %edi
773040f2:	56                   	push   %esi
773040f3:	50                   	push   %eax
773040f4:	e8 e7 fe ff ff       	call   77303fe0 <_GetTcpTable@12>
773040f9:	5e                   	pop    %esi
773040fa:	eb d7                	jmp    773040d3 <_AllocateAndGetTcpTableFromStack@16+0x33>
773040fc:	8d 74 26 00          	lea    0x0(%esi),%esi

77304100 <_GetUdpStatisticsEx@8>:


/******************************************************************
 *    GetUdpStatisticsEx (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pStats [In/Out]
 *  dwFamily [In]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetUdpStatisticsEx(PMIB_UDPSTATS pStats, DWORD dwFamily)
{
77304100:	55                   	push   %ebp
77304101:	89 e5                	mov    %esp,%ebp
77304103:	83 ec 10             	sub    $0x10,%esp
  DWORD ret;

  TRACE("pStats %p\n", pStats);
  ret = getUDPStats(pStats, dwFamily);
77304106:	8b 45 0c             	mov    0xc(%ebp),%eax
77304109:	50                   	push   %eax
7730410a:	8b 45 08             	mov    0x8(%ebp),%eax
7730410d:	50                   	push   %eax
7730410e:	e8 6d e7 ff ff       	call   77302880 <_getUDPStats>
  TRACE("returning %ld\n", ret);
  return ret;
}
77304113:	c9                   	leave  
77304114:	c2 08 00             	ret    $0x8
77304117:	89 f6                	mov    %esi,%esi
77304119:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77304120 <_GetUdpStatistics@4>:

/******************************************************************
 *    GetUdpStatistics (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pStats [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetUdpStatistics(PMIB_UDPSTATS pStats)
{
77304120:	55                   	push   %ebp
77304121:	89 e5                	mov    %esp,%ebp
77304123:	83 ec 10             	sub    $0x10,%esp
    return GetUdpStatisticsEx(pStats, PF_INET);
77304126:	8b 45 08             	mov    0x8(%ebp),%eax
77304129:	6a 02                	push   $0x2
7730412b:	50                   	push   %eax
7730412c:	e8 cf ff ff ff       	call   77304100 <_GetUdpStatisticsEx@8>
}
77304131:	c9                   	leave  
77304132:	c2 04 00             	ret    $0x4
77304135:	8d 74 26 00          	lea    0x0(%esi),%esi
77304139:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77304140 <_UdpTableSorter>:


static int UdpTableSorter(const void *a, const void *b)
{
77304140:	55                   	push   %ebp
77304141:	89 e5                	mov    %esp,%ebp
77304143:	56                   	push   %esi
77304144:	53                   	push   %ebx
77304145:	8b 75 08             	mov    0x8(%ebp),%esi
77304148:	8b 5d 0c             	mov    0xc(%ebp),%ebx
  int ret;

  if (a && b) {
7730414b:	85 f6                	test   %esi,%esi
7730414d:	0f 95 c2             	setne  %dl
77304150:	85 db                	test   %ebx,%ebx
77304152:	0f 95 c0             	setne  %al
77304155:	25 ff 00 00 00       	and    $0xff,%eax
    PMIB_UDPROW rowA = (PMIB_UDPROW)a, rowB = (PMIB_UDPROW)b;

    ret = rowA->dwLocalAddr - rowB->dwLocalAddr;
    if (ret == 0)
      ret = rowA->dwLocalPort - rowB->dwLocalPort;
  }
  else
    ret = 0;
7730415a:	31 c9                	xor    %ecx,%ecx
7730415c:	85 c2                	test   %eax,%edx
7730415e:	74 10                	je     77304170 <_UdpTableSorter+0x30>
77304160:	8b 06                	mov    (%esi),%eax
77304162:	89 c1                	mov    %eax,%ecx
77304164:	2b 0b                	sub    (%ebx),%ecx
77304166:	75 08                	jne    77304170 <_UdpTableSorter+0x30>
77304168:	8b 4e 04             	mov    0x4(%esi),%ecx
7730416b:	8b 43 04             	mov    0x4(%ebx),%eax
7730416e:	29 c1                	sub    %eax,%ecx
  return ret;
}
77304170:	89 c8                	mov    %ecx,%eax
77304172:	5b                   	pop    %ebx
77304173:	5e                   	pop    %esi
77304174:	5d                   	pop    %ebp
77304175:	c3                   	ret    
77304176:	8d 76 00             	lea    0x0(%esi),%esi
77304179:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77304180 <_GetUdpTable@12>:


/******************************************************************
 *    GetUdpTable (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pUdpTable [In/Out]
 *  pdwSize [In/Out]
 *  bOrder [In]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetUdpTable(PMIB_UDPTABLE pUdpTable, PDWORD pdwSize, BOOL bOrder)
{
77304180:	55                   	push   %ebp
77304181:	89 e5                	mov    %esp,%ebp
77304183:	57                   	push   %edi
77304184:	56                   	push   %esi
77304185:	53                   	push   %ebx
77304186:	83 ec 0c             	sub    $0xc,%esp
  DWORD ret;

  TRACE("pUdpTable %p, pdwSize %p, bOrder %ld\n", pUdpTable, pdwSize,
   (DWORD)bOrder);
  if (!pdwSize)
    ret = ERROR_INVALID_PARAMETER;
77304189:	be 57 00 00 00       	mov    $0x57,%esi
7730418e:	8b 7d 0c             	mov    0xc(%ebp),%edi
77304191:	85 ff                	test   %edi,%edi
77304193:	74 1e                	je     773041b3 <_GetUdpTable@12+0x33>
  else {
    DWORD numEntries = getNumUdpEntries();
77304195:	e8 46 ea ff ff       	call   77302be0 <_getNumUdpEntries>
    ULONG size = sizeof(MIB_UDPTABLE) + (numEntries - 1) * sizeof(MIB_UDPROW);

    if (!pUdpTable || *pdwSize < size) {
7730419a:	8b 5d 08             	mov    0x8(%ebp),%ebx
7730419d:	85 db                	test   %ebx,%ebx
7730419f:	8d 04 c5 04 00 00 00 	lea    0x4(,%eax,8),%eax
773041a6:	74 04                	je     773041ac <_GetUdpTable@12+0x2c>
773041a8:	39 07                	cmp    %eax,(%edi)
773041aa:	73 14                	jae    773041c0 <_GetUdpTable@12+0x40>
      *pdwSize = size;
773041ac:	89 07                	mov    %eax,(%edi)
      ret = ERROR_INSUFFICIENT_BUFFER;
773041ae:	be 7a 00 00 00       	mov    $0x7a,%esi
    }
    else {
      PMIB_UDPTABLE table = getUdpTable();

      if (table) {
        size = sizeof(MIB_UDPTABLE) + (table->dwNumEntries - 1) *
         sizeof(MIB_UDPROW);
        if (*pdwSize < size) {
          *pdwSize = size;
          ret = ERROR_INSUFFICIENT_BUFFER;
        }
        else {
          memcpy(pUdpTable, table, size);
          if (bOrder)
            qsort(pUdpTable->table, pUdpTable->dwNumEntries,
             sizeof(MIB_UDPROW), UdpTableSorter);
          ret = NO_ERROR;
        }
        free(table);
      }
      else
        ret = ERROR_OUTOFMEMORY;
    }
  }
  TRACE("returning %ld\n", ret);
  return ret;
}
773041b3:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773041b6:	89 f0                	mov    %esi,%eax
773041b8:	5b                   	pop    %ebx
773041b9:	5e                   	pop    %esi
773041ba:	5f                   	pop    %edi
773041bb:	5d                   	pop    %ebp
773041bc:	c2 0c 00             	ret    $0xc
773041bf:	90                   	nop    
773041c0:	e8 2b ea ff ff       	call   77302bf0 <_getUdpTable>
773041c5:	be 0e 00 00 00       	mov    $0xe,%esi
773041ca:	89 c3                	mov    %eax,%ebx
773041cc:	85 c0                	test   %eax,%eax
773041ce:	74 e3                	je     773041b3 <_GetUdpTable@12+0x33>
773041d0:	8b 00                	mov    (%eax),%eax
773041d2:	8d 04 c5 04 00 00 00 	lea    0x4(,%eax,8),%eax
773041d9:	39 07                	cmp    %eax,(%edi)
773041db:	73 1e                	jae    773041fb <_GetUdpTable@12+0x7b>
773041dd:	89 07                	mov    %eax,(%edi)
773041df:	66 be 7a 00          	mov    $0x7a,%si
773041e3:	83 ec 0c             	sub    $0xc,%esp
773041e6:	53                   	push   %ebx
773041e7:	e8 34 3d 00 00       	call   77307f20 <_free>
773041ec:	89 f0                	mov    %esi,%eax
773041ee:	83 c4 10             	add    $0x10,%esp
773041f1:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773041f4:	5b                   	pop    %ebx
773041f5:	5e                   	pop    %esi
773041f6:	5f                   	pop    %edi
773041f7:	5d                   	pop    %ebp
773041f8:	c2 0c 00             	ret    $0xc
773041fb:	fc                   	cld    
773041fc:	89 c1                	mov    %eax,%ecx
773041fe:	8b 7d 08             	mov    0x8(%ebp),%edi
77304201:	c1 e9 02             	shr    $0x2,%ecx
77304204:	89 de                	mov    %ebx,%esi
77304206:	f3 a5                	repz movsl %ds:(%esi),%es:(%edi)
77304208:	8b 4d 10             	mov    0x10(%ebp),%ecx
7730420b:	85 c9                	test   %ecx,%ecx
7730420d:	75 04                	jne    77304213 <_GetUdpTable@12+0x93>
7730420f:	31 f6                	xor    %esi,%esi
77304211:	eb d0                	jmp    773041e3 <_GetUdpTable@12+0x63>
77304213:	68 40 41 30 77       	push   $0x77304140
77304218:	6a 08                	push   $0x8
7730421a:	8b 45 08             	mov    0x8(%ebp),%eax
7730421d:	31 f6                	xor    %esi,%esi
7730421f:	8b 10                	mov    (%eax),%edx
77304221:	83 c0 04             	add    $0x4,%eax
77304224:	52                   	push   %edx
77304225:	50                   	push   %eax
77304226:	e8 95 37 00 00       	call   773079c0 <_qsort>
7730422b:	83 c4 10             	add    $0x10,%esp
7730422e:	eb b3                	jmp    773041e3 <_GetUdpTable@12+0x63>

77304230 <_AllocateAndGetUdpTableFromStack@16>:
77304230:	55                   	push   %ebp
77304231:	b8 57 00 00 00       	mov    $0x57,%eax
77304236:	89 e5                	mov    %esp,%ebp
77304238:	57                   	push   %edi
77304239:	56                   	push   %esi
7730423a:	53                   	push   %ebx
7730423b:	83 ec 0c             	sub    $0xc,%esp
7730423e:	8b 5d 08             	mov    0x8(%ebp),%ebx
77304241:	8b 7d 0c             	mov    0xc(%ebp),%edi
77304244:	85 db                	test   %ebx,%ebx
77304246:	74 1b                	je     77304263 <_AllocateAndGetUdpTableFromStack@16+0x33>
77304248:	56                   	push   %esi
77304249:	8d 75 f0             	lea    0xfffffff0(%ebp),%esi
7730424c:	57                   	push   %edi
7730424d:	56                   	push   %esi
7730424e:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
77304255:	8b 0b                	mov    (%ebx),%ecx
77304257:	51                   	push   %ecx
77304258:	e8 23 ff ff ff       	call   77304180 <_GetUdpTable@12>
7730425d:	5a                   	pop    %edx
7730425e:	83 f8 7a             	cmp    $0x7a,%eax
77304261:	74 0a                	je     7730426d <_AllocateAndGetUdpTableFromStack@16+0x3d>
77304263:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77304266:	5b                   	pop    %ebx
77304267:	5e                   	pop    %esi
77304268:	5f                   	pop    %edi
77304269:	5d                   	pop    %ebp
7730426a:	c2 10 00             	ret    $0x10
7730426d:	50                   	push   %eax
7730426e:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
77304271:	50                   	push   %eax
77304272:	8b 45 14             	mov    0x14(%ebp),%eax
77304275:	50                   	push   %eax
77304276:	8b 45 10             	mov    0x10(%ebp),%eax
77304279:	50                   	push   %eax
7730427a:	e8 c1 11 00 00       	call   77305440 <_HeapAlloc@12>
7730427f:	89 03                	mov    %eax,(%ebx)
77304281:	57                   	push   %edi
77304282:	56                   	push   %esi
77304283:	50                   	push   %eax
77304284:	e8 f7 fe ff ff       	call   77304180 <_GetUdpTable@12>
77304289:	5e                   	pop    %esi
7730428a:	eb d7                	jmp    77304263 <_AllocateAndGetUdpTableFromStack@16+0x33>
7730428c:	8d 74 26 00          	lea    0x0(%esi),%esi

77304290 <_GetUniDirectionalAdapterInfo@8>:


/******************************************************************
 *    GetUniDirectionalAdapterInfo (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pIPIfInfo [In/Out]
 *  dwOutBufLen [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI GetUniDirectionalAdapterInfo(PIP_UNIDIRECTIONAL_ADAPTER_ADDRESS pIPIfInfo, PULONG dwOutBufLen)
{
77304290:	55                   	push   %ebp
  TRACE("pIPIfInfo %p, dwOutBufLen %p\n", pIPIfInfo, dwOutBufLen);
  /* a unidirectional adapter?? not bloody likely! */
  return ERROR_NOT_SUPPORTED;
}
77304291:	b8 32 00 00 00       	mov    $0x32,%eax
77304296:	89 e5                	mov    %esp,%ebp
77304298:	5d                   	pop    %ebp
77304299:	c2 08 00             	ret    $0x8
7730429c:	8d 74 26 00          	lea    0x0(%esi),%esi

773042a0 <_IpReleaseAddress@4>:


/******************************************************************
 *    IpReleaseAddress (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  AdapterInfo [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI IpReleaseAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo)
{
773042a0:	55                   	push   %ebp
  TRACE("AdapterInfo %p\n", AdapterInfo);
  /* not a stub, never going to support this (and I never mark an adapter as
     DHCP enabled, see GetAdaptersInfo, so this should never get called) */
  return ERROR_NOT_SUPPORTED;
}
773042a1:	b8 32 00 00 00       	mov    $0x32,%eax
773042a6:	89 e5                	mov    %esp,%ebp
773042a8:	5d                   	pop    %ebp
773042a9:	c2 04 00             	ret    $0x4
773042ac:	8d 74 26 00          	lea    0x0(%esi),%esi

773042b0 <_IpRenewAddress@4>:


/******************************************************************
 *    IpRenewAddress (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  AdapterInfo [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI IpRenewAddress(PIP_ADAPTER_INDEX_MAP AdapterInfo)
{
773042b0:	55                   	push   %ebp
  TRACE("AdapterInfo %p\n", AdapterInfo);
  /* not a stub, never going to support this (and I never mark an adapter as
     DHCP enabled, see GetAdaptersInfo, so this should never get called) */
  return ERROR_NOT_SUPPORTED;
}
773042b1:	b8 32 00 00 00       	mov    $0x32,%eax
773042b6:	89 e5                	mov    %esp,%ebp
773042b8:	5d                   	pop    %ebp
773042b9:	c2 04 00             	ret    $0x4
773042bc:	8d 74 26 00          	lea    0x0(%esi),%esi

773042c0 <_NotifyAddrChange@8>:


/******************************************************************
 *    NotifyAddrChange (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  Handle [In/Out]
 *  overlapped [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI NotifyAddrChange(PHANDLE Handle, LPOVERLAPPED overlapped)
{
773042c0:	55                   	push   %ebp
773042c1:	89 e5                	mov    %esp,%ebp
773042c3:	50                   	push   %eax
773042c4:	50                   	push   %eax
  TRACE("Handle %p, overlapped %p\n", Handle, overlapped);
  FIXME(":stub\n");
773042c5:	68 73 a2 30 77       	push   $0x7730a273
773042ca:	68 0d 07 00 00       	push   $0x70d
773042cf:	68 fd a0 30 77       	push   $0x7730a0fd
773042d4:	68 0d a1 30 77       	push   $0x7730a10d
773042d9:	e8 a2 36 00 00       	call   77307980 <_DbgPrint>
773042de:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
773042e5:	e8 96 36 00 00       	call   77307980 <_DbgPrint>
  /* marking Win2K+ functions not supported */
  return ERROR_NOT_SUPPORTED;
}
773042ea:	b8 32 00 00 00       	mov    $0x32,%eax
773042ef:	c9                   	leave  
773042f0:	c2 08 00             	ret    $0x8
773042f3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
773042f9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77304300 <_NotifyRouteChange@8>:


/******************************************************************
 *    NotifyRouteChange (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  Handle [In/Out]
 *  overlapped [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI NotifyRouteChange(PHANDLE Handle, LPOVERLAPPED overlapped)
{
77304300:	55                   	push   %ebp
77304301:	89 e5                	mov    %esp,%ebp
77304303:	50                   	push   %eax
77304304:	50                   	push   %eax
  TRACE("Handle %p, overlapped %p\n", Handle, overlapped);
  FIXME(":stub\n");
77304305:	68 84 a2 30 77       	push   $0x7730a284
7730430a:	68 24 07 00 00       	push   $0x724
7730430f:	68 fd a0 30 77       	push   $0x7730a0fd
77304314:	68 0d a1 30 77       	push   $0x7730a10d
77304319:	e8 62 36 00 00       	call   77307980 <_DbgPrint>
7730431e:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77304325:	e8 56 36 00 00       	call   77307980 <_DbgPrint>
  /* marking Win2K+ functions not supported */
  return ERROR_NOT_SUPPORTED;
}
7730432a:	b8 32 00 00 00       	mov    $0x32,%eax
7730432f:	c9                   	leave  
77304330:	c2 08 00             	ret    $0x8
77304333:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77304339:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77304340 <_SendARP@16>:


/******************************************************************
 *    SendARP (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  DestIP [In]
 *  SrcIP [In]
 *  pMacAddr [In/Out]
 *  PhyAddrLen [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI SendARP(IPAddr DestIP, IPAddr SrcIP, PULONG pMacAddr, PULONG PhyAddrLen)
{
77304340:	55                   	push   %ebp
77304341:	89 e5                	mov    %esp,%ebp
77304343:	50                   	push   %eax
77304344:	50                   	push   %eax
  TRACE("DestIP 0x%08lx, SrcIP 0x%08lx, pMacAddr %p, PhyAddrLen %p\n", DestIP,
   SrcIP, pMacAddr, PhyAddrLen);
  FIXME(":stub\n");
77304345:	68 96 a2 30 77       	push   $0x7730a296
7730434a:	68 3e 07 00 00       	push   $0x73e
7730434f:	68 fd a0 30 77       	push   $0x7730a0fd
77304354:	68 0d a1 30 77       	push   $0x7730a10d
77304359:	e8 22 36 00 00       	call   77307980 <_DbgPrint>
7730435e:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77304365:	e8 16 36 00 00       	call   77307980 <_DbgPrint>
  /* marking Win2K+ functions not supported */
  return ERROR_NOT_SUPPORTED;
}
7730436a:	b8 32 00 00 00       	mov    $0x32,%eax
7730436f:	c9                   	leave  
77304370:	c2 10 00             	ret    $0x10
77304373:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77304379:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77304380 <_SetIfEntry@4>:


/******************************************************************
 *    SetIfEntry (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pIfRow [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI SetIfEntry(PMIB_IFROW pIfRow)
{
77304380:	55                   	push   %ebp
77304381:	89 e5                	mov    %esp,%ebp
77304383:	50                   	push   %eax
77304384:	50                   	push   %eax
  TRACE("pIfRow %p\n", pIfRow);
  /* this is supposed to set an administratively interface up or down.
     Could do SIOCSIFFLAGS and set/clear IFF_UP, but, not sure I want to, and
     this sort of down is indistinguishable from other sorts of down (e.g. no
     link). */
  FIXME(":stub\n");
77304385:	68 9e a2 30 77       	push   $0x7730a29e
7730438a:	68 58 07 00 00       	push   $0x758
7730438f:	68 fd a0 30 77       	push   $0x7730a0fd
77304394:	68 0d a1 30 77       	push   $0x7730a10d
77304399:	e8 e2 35 00 00       	call   77307980 <_DbgPrint>
7730439e:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
773043a5:	e8 d6 35 00 00       	call   77307980 <_DbgPrint>
  return ERROR_NOT_SUPPORTED;
}
773043aa:	b8 32 00 00 00       	mov    $0x32,%eax
773043af:	c9                   	leave  
773043b0:	c2 04 00             	ret    $0x4
773043b3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
773043b9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

773043c0 <_SetIpForwardEntry@4>:


/******************************************************************
 *    SetIpForwardEntry (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pRoute [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI SetIpForwardEntry(PMIB_IPFORWARDROW pRoute)
{
773043c0:	55                   	push   %ebp
773043c1:	89 e5                	mov    %esp,%ebp
773043c3:	83 ec 14             	sub    $0x14,%esp
    return setIpForwardEntry( pRoute );
773043c6:	8b 45 08             	mov    0x8(%ebp),%eax
773043c9:	50                   	push   %eax
773043ca:	e8 11 0a 00 00       	call   77304de0 <_setIpForwardEntry>
}
773043cf:	c9                   	leave  
773043d0:	c2 04 00             	ret    $0x4
773043d3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
773043d9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

773043e0 <_SetIpNetEntry@4>:


/******************************************************************
 *    SetIpNetEntry (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pArpEntry [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI SetIpNetEntry(PMIB_IPNETROW pArpEntry)
{
773043e0:	55                   	push   %ebp
773043e1:	89 e5                	mov    %esp,%ebp
773043e3:	50                   	push   %eax
773043e4:	50                   	push   %eax
  TRACE("pArpEntry %p\n", pArpEntry);
  /* same as CreateIpNetEntry here, could use SIOCSARP, not sure I want to */
  FIXME(":stub\n");
773043e5:	68 a9 a2 30 77       	push   $0x7730a2a9
773043ea:	68 81 07 00 00       	push   $0x781
773043ef:	68 fd a0 30 77       	push   $0x7730a0fd
773043f4:	68 0d a1 30 77       	push   $0x7730a10d
773043f9:	e8 82 35 00 00       	call   77307980 <_DbgPrint>
773043fe:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77304405:	e8 76 35 00 00       	call   77307980 <_DbgPrint>
  return (DWORD) 0;
}
7730440a:	31 c0                	xor    %eax,%eax
7730440c:	c9                   	leave  
7730440d:	c2 04 00             	ret    $0x4

77304410 <_SetIpStatistics@4>:


/******************************************************************
 *    SetIpStatistics (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pIpStats [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI SetIpStatistics(PMIB_IPSTATS pIpStats)
{
77304410:	55                   	push   %ebp
77304411:	89 e5                	mov    %esp,%ebp
77304413:	52                   	push   %edx
77304414:	52                   	push   %edx
  TRACE("pIpStats %p\n", pIpStats);
  FIXME(":stub\n");
77304415:	68 b7 a2 30 77       	push   $0x7730a2b7
7730441a:	68 96 07 00 00       	push   $0x796
7730441f:	68 fd a0 30 77       	push   $0x7730a0fd
77304424:	68 0d a1 30 77       	push   $0x7730a10d
77304429:	e8 52 35 00 00       	call   77307980 <_DbgPrint>
7730442e:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77304435:	e8 46 35 00 00       	call   77307980 <_DbgPrint>
  return (DWORD) 0;
}
7730443a:	31 c0                	xor    %eax,%eax
7730443c:	c9                   	leave  
7730443d:	c2 04 00             	ret    $0x4

77304440 <_SetIpTTL@4>:


/******************************************************************
 *    SetIpTTL (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  nTTL [In]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI SetIpTTL(UINT nTTL)
{
77304440:	55                   	push   %ebp
77304441:	89 e5                	mov    %esp,%ebp
77304443:	51                   	push   %ecx
77304444:	51                   	push   %ecx
  TRACE("nTTL %d\n", nTTL);
  /* could echo nTTL > /proc/net/sys/net/ipv4/ip_default_ttl, not sure I
     want to.  Could map EACCESS to ERROR_ACCESS_DENIED, I suppose */
  FIXME(":stub\n");
77304445:	68 c7 a2 30 77       	push   $0x7730a2c7
7730444a:	68 ad 07 00 00       	push   $0x7ad
7730444f:	68 fd a0 30 77       	push   $0x7730a0fd
77304454:	68 0d a1 30 77       	push   $0x7730a10d
77304459:	e8 22 35 00 00       	call   77307980 <_DbgPrint>
7730445e:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77304465:	e8 16 35 00 00       	call   77307980 <_DbgPrint>
  return (DWORD) 0;
}
7730446a:	31 c0                	xor    %eax,%eax
7730446c:	c9                   	leave  
7730446d:	c2 04 00             	ret    $0x4

77304470 <_SetTcpEntry@4>:


/******************************************************************
 *    SetTcpEntry (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pTcpRow [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI SetTcpEntry(PMIB_TCPROW pTcpRow)
{
77304470:	55                   	push   %ebp
77304471:	89 e5                	mov    %esp,%ebp
77304473:	50                   	push   %eax
77304474:	50                   	push   %eax
  TRACE("pTcpRow %p\n", pTcpRow);
  FIXME(":stub\n");
77304475:	68 d0 a2 30 77       	push   $0x7730a2d0
7730447a:	68 c2 07 00 00       	push   $0x7c2
7730447f:	68 fd a0 30 77       	push   $0x7730a0fd
77304484:	68 0d a1 30 77       	push   $0x7730a10d
77304489:	e8 f2 34 00 00       	call   77307980 <_DbgPrint>
7730448e:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77304495:	e8 e6 34 00 00       	call   77307980 <_DbgPrint>
  return (DWORD) 0;
}
7730449a:	31 c0                	xor    %eax,%eax
7730449c:	c9                   	leave  
7730449d:	c2 04 00             	ret    $0x4

773044a0 <_UnenableRouter@8>:


/******************************************************************
 *    UnenableRouter (IPHLPAPI.@)
 *
 *
 * PARAMS
 *
 *  pOverlapped [In/Out]
 *  lpdwEnableCount [In/Out]
 *
 * RETURNS
 *
 *  DWORD
 *
 */
DWORD WINAPI UnenableRouter(OVERLAPPED * pOverlapped, LPDWORD lpdwEnableCount)
{
773044a0:	55                   	push   %ebp
773044a1:	89 e5                	mov    %esp,%ebp
773044a3:	50                   	push   %eax
773044a4:	50                   	push   %eax
  TRACE("pOverlapped %p, lpdwEnableCount %p\n", pOverlapped, lpdwEnableCount);
  FIXME(":stub\n");
773044a5:	68 dc a2 30 77       	push   $0x7730a2dc
773044aa:	68 d8 07 00 00       	push   $0x7d8
773044af:	68 fd a0 30 77       	push   $0x7730a0fd
773044b4:	68 0d a1 30 77       	push   $0x7730a10d
773044b9:	e8 c2 34 00 00       	call   77307980 <_DbgPrint>
773044be:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
773044c5:	e8 b6 34 00 00       	call   77307980 <_DbgPrint>
  /* could echo "0" > /proc/net/sys/net/ipv4/ip_forward, not sure I want to
     could map EACCESS to ERROR_ACCESS_DENIED, I suppose
     marking Win2K+ functions not supported */
  return ERROR_NOT_SUPPORTED;
}
773044ca:	b8 32 00 00 00       	mov    $0x32,%eax
773044cf:	c9                   	leave  
773044d0:	c2 08 00             	ret    $0x8
773044d3:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
773044d9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

773044e0 <_GetIpErrorString@12>:

/*
 * @unimplemented
 */
DWORD WINAPI GetIpErrorString(IP_STATUS ErrorCode,PWCHAR Buffer,PDWORD Size)
{
773044e0:	55                   	push   %ebp
773044e1:	89 e5                	mov    %esp,%ebp
773044e3:	50                   	push   %eax
773044e4:	50                   	push   %eax
    FIXME(":stub\n");
773044e5:	68 eb a2 30 77       	push   $0x7730a2eb
773044ea:	68 e4 07 00 00       	push   $0x7e4
773044ef:	68 fd a0 30 77       	push   $0x7730a0fd
773044f4:	68 0d a1 30 77       	push   $0x7730a10d
773044f9:	e8 82 34 00 00       	call   77307980 <_DbgPrint>
773044fe:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77304505:	e8 76 34 00 00       	call   77307980 <_DbgPrint>
    return 0L;
}
7730450a:	31 c0                	xor    %eax,%eax
7730450c:	c9                   	leave  
7730450d:	c2 0c 00             	ret    $0xc

77304510 <_GetAdapterOrderMap@0>:


/*
 * @unimplemented
 */
PIP_ADAPTER_ORDER_MAP WINAPI GetAdapterOrderMap(VOID)
{
77304510:	55                   	push   %ebp
77304511:	89 e5                	mov    %esp,%ebp
77304513:	50                   	push   %eax
77304514:	50                   	push   %eax
    FIXME(":stub\n");
77304515:	68 fc a2 30 77       	push   $0x7730a2fc
7730451a:	68 ee 07 00 00       	push   $0x7ee
7730451f:	68 fd a0 30 77       	push   $0x7730a0fd
77304524:	68 0d a1 30 77       	push   $0x7730a10d
77304529:	e8 52 34 00 00       	call   77307980 <_DbgPrint>
7730452e:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77304535:	e8 46 34 00 00       	call   77307980 <_DbgPrint>
    return 0L;
}
7730453a:	31 c0                	xor    %eax,%eax
7730453c:	c9                   	leave  
7730453d:	c3                   	ret    
7730453e:	89 f6                	mov    %esi,%esi

77304540 <_GetAdaptersAddresses@20>:

/*
 * @unimplemented
 */
DWORD WINAPI GetAdaptersAddresses(ULONG Family,DWORD Flags,PVOID Reserved,PIP_ADAPTER_ADDRESSES pAdapterAddresses,PULONG pOutBufLen)
{
77304540:	55                   	push   %ebp
77304541:	89 e5                	mov    %esp,%ebp
77304543:	50                   	push   %eax
77304544:	50                   	push   %eax
    FIXME(":stub\n");
77304545:	68 0f a3 30 77       	push   $0x7730a30f
7730454a:	68 f7 07 00 00       	push   $0x7f7
7730454f:	68 fd a0 30 77       	push   $0x7730a0fd
77304554:	68 0d a1 30 77       	push   $0x7730a10d
77304559:	e8 22 34 00 00       	call   77307980 <_DbgPrint>
7730455e:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77304565:	e8 16 34 00 00       	call   77307980 <_DbgPrint>
    return 0L;
}
7730456a:	31 c0                	xor    %eax,%eax
7730456c:	c9                   	leave  
7730456d:	c2 14 00             	ret    $0x14

77304570 <_CancelIPChangeNotify@4>:

/*
 * @unimplemented
 */
BOOL WINAPI CancelIPChangeNotify(LPOVERLAPPED notifyOverlapped)
{
77304570:	55                   	push   %ebp
77304571:	89 e5                	mov    %esp,%ebp
77304573:	50                   	push   %eax
77304574:	50                   	push   %eax
    FIXME(":stub\n");
77304575:	68 24 a3 30 77       	push   $0x7730a324
7730457a:	68 00 08 00 00       	push   $0x800
7730457f:	68 fd a0 30 77       	push   $0x7730a0fd
77304584:	68 0d a1 30 77       	push   $0x7730a10d
77304589:	e8 f2 33 00 00       	call   77307980 <_DbgPrint>
7730458e:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77304595:	e8 e6 33 00 00       	call   77307980 <_DbgPrint>
    return 0L;
}
7730459a:	31 c0                	xor    %eax,%eax
7730459c:	c9                   	leave  
7730459d:	c2 04 00             	ret    $0x4

773045a0 <_GetBestInterfaceEx@8>:

/*
 * @unimplemented
 */
DWORD WINAPI GetBestInterfaceEx(struct sockaddr *pDestAddr,PDWORD pdwBestIfIndex)
{
773045a0:	55                   	push   %ebp
773045a1:	89 e5                	mov    %esp,%ebp
773045a3:	52                   	push   %edx
773045a4:	52                   	push   %edx
    FIXME(":stub\n");
773045a5:	68 39 a3 30 77       	push   $0x7730a339
773045aa:	68 09 08 00 00       	push   $0x809
773045af:	68 fd a0 30 77       	push   $0x7730a0fd
773045b4:	68 0d a1 30 77       	push   $0x7730a10d
773045b9:	e8 c2 33 00 00       	call   77307980 <_DbgPrint>
773045be:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
773045c5:	e8 b6 33 00 00       	call   77307980 <_DbgPrint>
    return 0L;
}
773045ca:	31 c0                	xor    %eax,%eax
773045cc:	c9                   	leave  
773045cd:	c2 08 00             	ret    $0x8

773045d0 <_NhpAllocateAndGetInterfaceInfoFromStack@20>:

/*
 * @unimplemented
 */
DWORD WINAPI NhpAllocateAndGetInterfaceInfoFromStack(IP_INTERFACE_NAME_INFO **ppTable,PDWORD pdwCount,BOOL bOrder,HANDLE hHeap,DWORD dwFlags)
{
773045d0:	55                   	push   %ebp
773045d1:	89 e5                	mov    %esp,%ebp
773045d3:	51                   	push   %ecx
773045d4:	51                   	push   %ecx
    FIXME(":stub\n");
773045d5:	68 50 a3 30 77       	push   $0x7730a350
773045da:	68 12 08 00 00       	push   $0x812
773045df:	68 fd a0 30 77       	push   $0x7730a0fd
773045e4:	68 0d a1 30 77       	push   $0x7730a10d
773045e9:	e8 92 33 00 00       	call   77307980 <_DbgPrint>
773045ee:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
773045f5:	e8 86 33 00 00       	call   77307980 <_DbgPrint>
    return 0L;
}
773045fa:	31 c0                	xor    %eax,%eax
773045fc:	c9                   	leave  
773045fd:	c2 14 00             	ret    $0x14

77304600 <_GetIcmpStatisticsEx@8>:

/*
 * @unimplemented
 */
DWORD WINAPI GetIcmpStatisticsEx(PMIB_ICMP_EX pStats,DWORD dwFamily)
{
77304600:	55                   	push   %ebp
77304601:	89 e5                	mov    %esp,%ebp
77304603:	50                   	push   %eax
77304604:	50                   	push   %eax
    FIXME(":stub\n");
77304605:	68 78 a3 30 77       	push   $0x7730a378
7730460a:	68 1b 08 00 00       	push   $0x81b
7730460f:	68 fd a0 30 77       	push   $0x7730a0fd
77304614:	68 0d a1 30 77       	push   $0x7730a10d
77304619:	e8 62 33 00 00       	call   77307980 <_DbgPrint>
7730461e:	c7 04 24 19 a1 30 77 	movl   $0x7730a119,(%esp)
77304625:	e8 56 33 00 00       	call   77307980 <_DbgPrint>
    return 0L;
}
7730462a:	31 c0                	xor    %eax,%eax
7730462c:	c9                   	leave  
7730462d:	c2 08 00             	ret    $0x8

77304630 <_DisableMediaSense@8>:
/*
 * @unimplemented
 */
DWORD STDCALL DisableMediaSense(HANDLE *pHandle,OVERLAPPED *pOverLapped)
{
77304630:	55                   	push   %ebp
77304631:	89 e5                	mov    %esp,%ebp
77304633:	50                   	push   %eax
77304634:	50                   	push   %eax
    UNIMPLEMENTED
77304635:	6a 1b                	push   $0x1b
77304637:	68 a2 a3 30 77       	push   $0x7730a3a2
7730463c:	68 90 a3 30 77       	push   $0x7730a390
77304641:	68 ac a3 30 77       	push   $0x7730a3ac
77304646:	e8 35 33 00 00       	call   77307980 <_DbgPrint>
    return 0L;
}
7730464b:	31 c0                	xor    %eax,%eax
7730464d:	c9                   	leave  
7730464e:	c2 08 00             	ret    $0x8
77304651:	eb 0d                	jmp    77304660 <_RestoreMediaSense@8>
77304653:	90                   	nop    
77304654:	90                   	nop    
77304655:	90                   	nop    
77304656:	90                   	nop    
77304657:	90                   	nop    
77304658:	90                   	nop    
77304659:	90                   	nop    
7730465a:	90                   	nop    
7730465b:	90                   	nop    
7730465c:	90                   	nop    
7730465d:	90                   	nop    
7730465e:	90                   	nop    
7730465f:	90                   	nop    

77304660 <_RestoreMediaSense@8>:

/*
 * @unimplemented
 */
DWORD STDCALL RestoreMediaSense(OVERLAPPED* pOverlapped,LPDWORD lpdwEnableCount)
{
77304660:	55                   	push   %ebp
77304661:	89 e5                	mov    %esp,%ebp
77304663:	52                   	push   %edx
77304664:	52                   	push   %edx
    UNIMPLEMENTED
77304665:	6a 24                	push   $0x24
77304667:	68 a2 a3 30 77       	push   $0x7730a3a2
7730466c:	68 d5 a3 30 77       	push   $0x7730a3d5
77304671:	68 ac a3 30 77       	push   $0x7730a3ac
77304676:	e8 05 33 00 00       	call   77307980 <_DbgPrint>
    return 0L;
}
7730467b:	31 c0                	xor    %eax,%eax
7730467d:	c9                   	leave  
7730467e:	c2 08 00             	ret    $0x8
77304681:	90                   	nop    
77304682:	90                   	nop    
77304683:	90                   	nop    
77304684:	90                   	nop    
77304685:	90                   	nop    
77304686:	90                   	nop    
77304687:	90                   	nop    
77304688:	90                   	nop    
77304689:	90                   	nop    
7730468a:	90                   	nop    
7730468b:	90                   	nop    
7730468c:	90                   	nop    
7730468d:	90                   	nop    
7730468e:	90                   	nop    
7730468f:	90                   	nop    

77304690 <_GetLongestChildKeyName>:
77304690:	55                   	push   %ebp
77304691:	89 e5                	mov    %esp,%ebp
77304693:	52                   	push   %edx
77304694:	52                   	push   %edx
77304695:	6a 00                	push   $0x0
77304697:	8d 45 fc             	lea    0xfffffffc(%ebp),%eax
7730469a:	6a 00                	push   $0x0
7730469c:	6a 00                	push   $0x0
7730469e:	6a 00                	push   $0x0
773046a0:	6a 00                	push   $0x0
773046a2:	6a 00                	push   $0x0
773046a4:	50                   	push   %eax
773046a5:	8b 45 08             	mov    0x8(%ebp),%eax
773046a8:	6a 00                	push   $0x0
773046aa:	6a 00                	push   $0x0
773046ac:	6a 00                	push   $0x0
773046ae:	6a 00                	push   $0x0
773046b0:	50                   	push   %eax
773046b1:	e8 2a 0d 00 00       	call   773053e0 <_RegQueryInfoKeyW@48>
773046b6:	83 ca ff             	or     $0xffffffff,%edx
773046b9:	85 c0                	test   %eax,%eax
773046bb:	75 04                	jne    773046c1 <_GetLongestChildKeyName+0x31>
773046bd:	8b 55 fc             	mov    0xfffffffc(%ebp),%edx
773046c0:	42                   	inc    %edx
773046c1:	89 d0                	mov    %edx,%eax
773046c3:	c9                   	leave  
773046c4:	c3                   	ret    
773046c5:	8d 74 26 00          	lea    0x0(%esi),%esi
773046c9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

773046d0 <_OpenChildKeyRead>:
773046d0:	55                   	push   %ebp
773046d1:	89 e5                	mov    %esp,%ebp
773046d3:	83 ec 14             	sub    $0x14,%esp
773046d6:	8b 45 10             	mov    0x10(%ebp),%eax
773046d9:	8b 4d 08             	mov    0x8(%ebp),%ecx
773046dc:	50                   	push   %eax
773046dd:	8b 45 0c             	mov    0xc(%ebp),%eax
773046e0:	68 19 00 02 00       	push   $0x20019
773046e5:	6a 00                	push   $0x0
773046e7:	50                   	push   %eax
773046e8:	51                   	push   %ecx
773046e9:	e8 02 0d 00 00       	call   773053f0 <_RegOpenKeyExW@20>
773046ee:	c9                   	leave  
773046ef:	c3                   	ret    

773046f0 <_GetNthChildKeyName>:
773046f0:	55                   	push   %ebp
773046f1:	89 e5                	mov    %esp,%ebp
773046f3:	56                   	push   %esi
773046f4:	53                   	push   %ebx
773046f5:	83 ec 1c             	sub    $0x1c,%esp
773046f8:	8b 75 08             	mov    0x8(%ebp),%esi
773046fb:	56                   	push   %esi
773046fc:	e8 8f ff ff ff       	call   77304690 <_GetLongestChildKeyName>
77304701:	83 c4 10             	add    $0x10,%esp
77304704:	83 f8 ff             	cmp    $0xffffffff,%eax
77304707:	74 4d                	je     77304756 <_GetNthChildKeyName+0x66>
77304709:	89 45 f4             	mov    %eax,0xfffffff4(%ebp)
7730470c:	52                   	push   %edx
7730470d:	50                   	push   %eax
7730470e:	6a 00                	push   $0x0
77304710:	50                   	push   %eax
77304711:	e8 1a 0d 00 00       	call   77305430 <_GetProcessHeap@0>
77304716:	89 04 24             	mov    %eax,(%esp)
77304719:	e8 22 0d 00 00       	call   77305440 <_HeapAlloc@12>
7730471e:	89 c3                	mov    %eax,%ebx
77304720:	8d 45 f4             	lea    0xfffffff4(%ebp),%eax
77304723:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
7730472a:	6a 00                	push   $0x0
7730472c:	6a 00                	push   $0x0
7730472e:	6a 00                	push   $0x0
77304730:	50                   	push   %eax
77304731:	8b 45 0c             	mov    0xc(%ebp),%eax
77304734:	53                   	push   %ebx
77304735:	50                   	push   %eax
77304736:	56                   	push   %esi
77304737:	e8 c4 0c 00 00       	call   77305400 <_RegEnumKeyExW@32>
7730473c:	31 d2                	xor    %edx,%edx
7730473e:	85 c0                	test   %eax,%eax
77304740:	75 0b                	jne    7730474d <_GetNthChildKeyName+0x5d>
77304742:	8b 45 f4             	mov    0xfffffff4(%ebp),%eax
77304745:	89 da                	mov    %ebx,%edx
77304747:	66 c7 04 43 00 00    	movw   $0x0,(%ebx,%eax,2)
7730474d:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
77304750:	89 d0                	mov    %edx,%eax
77304752:	5b                   	pop    %ebx
77304753:	5e                   	pop    %esi
77304754:	5d                   	pop    %ebp
77304755:	c3                   	ret    
77304756:	83 ec 0c             	sub    $0xc,%esp
77304759:	56                   	push   %esi
7730475a:	e8 71 0c 00 00       	call   773053d0 <_RegCloseKey@4>
7730475f:	31 d2                	xor    %edx,%edx
77304761:	eb ea                	jmp    7730474d <_GetNthChildKeyName+0x5d>
77304763:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77304769:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77304770 <_ConsumeChildKeyName>:
77304770:	55                   	push   %ebp
77304771:	89 e5                	mov    %esp,%ebp
77304773:	51                   	push   %ecx
77304774:	51                   	push   %ecx
77304775:	8b 45 08             	mov    0x8(%ebp),%eax
77304778:	85 c0                	test   %eax,%eax
7730477a:	74 13                	je     7730478f <_ConsumeChildKeyName+0x1f>
7730477c:	52                   	push   %edx
7730477d:	50                   	push   %eax
7730477e:	6a 00                	push   $0x0
77304780:	50                   	push   %eax
77304781:	e8 aa 0c 00 00       	call   77305430 <_GetProcessHeap@0>
77304786:	89 04 24             	mov    %eax,(%esp)
77304789:	e8 c2 0c 00 00       	call   77305450 <_HeapFree@12>
7730478e:	59                   	pop    %ecx
7730478f:	c9                   	leave  
77304790:	c3                   	ret    
77304791:	eb 0d                	jmp    773047a0 <_QueryRegistryValueString>
77304793:	90                   	nop    
77304794:	90                   	nop    
77304795:	90                   	nop    
77304796:	90                   	nop    
77304797:	90                   	nop    
77304798:	90                   	nop    
77304799:	90                   	nop    
7730479a:	90                   	nop    
7730479b:	90                   	nop    
7730479c:	90                   	nop    
7730479d:	90                   	nop    
7730479e:	90                   	nop    
7730479f:	90                   	nop    

773047a0 <_QueryRegistryValueString>:
773047a0:	55                   	push   %ebp
773047a1:	89 e5                	mov    %esp,%ebp
773047a3:	57                   	push   %edi
773047a4:	56                   	push   %esi
773047a5:	53                   	push   %ebx
773047a6:	83 ec 14             	sub    $0x14,%esp
773047a9:	8d 75 f0             	lea    0xfffffff0(%ebp),%esi
773047ac:	8b 7d 0c             	mov    0xc(%ebp),%edi
773047af:	8b 4d 08             	mov    0x8(%ebp),%ecx
773047b2:	56                   	push   %esi
773047b3:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
773047ba:	6a 00                	push   $0x0
773047bc:	6a 00                	push   $0x0
773047be:	6a 00                	push   $0x0
773047c0:	57                   	push   %edi
773047c1:	51                   	push   %ecx
773047c2:	e8 49 0c 00 00       	call   77305410 <_RegQueryValueExW@24>
773047c7:	5b                   	pop    %ebx
773047c8:	5a                   	pop    %edx
773047c9:	31 d2                	xor    %edx,%edx
773047cb:	85 c0                	test   %eax,%eax
773047cd:	75 22                	jne    773047f1 <_QueryRegistryValueString+0x51>
773047cf:	83 ec 0c             	sub    $0xc,%esp
773047d2:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
773047d5:	51                   	push   %ecx
773047d6:	e8 65 37 00 00       	call   77307f40 <_malloc>
773047db:	89 c3                	mov    %eax,%ebx
773047dd:	58                   	pop    %eax
773047de:	5a                   	pop    %edx
773047df:	56                   	push   %esi
773047e0:	8b 75 08             	mov    0x8(%ebp),%esi
773047e3:	53                   	push   %ebx
773047e4:	6a 00                	push   $0x0
773047e6:	6a 00                	push   $0x0
773047e8:	57                   	push   %edi
773047e9:	56                   	push   %esi
773047ea:	e8 21 0c 00 00       	call   77305410 <_RegQueryValueExW@24>
773047ef:	89 da                	mov    %ebx,%edx
773047f1:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773047f4:	89 d0                	mov    %edx,%eax
773047f6:	5b                   	pop    %ebx
773047f7:	5e                   	pop    %esi
773047f8:	5f                   	pop    %edi
773047f9:	5d                   	pop    %ebp
773047fa:	c3                   	ret    
773047fb:	90                   	nop    
773047fc:	8d 74 26 00          	lea    0x0(%esi),%esi

77304800 <_ConsumeRegValueString>:
77304800:	55                   	push   %ebp
77304801:	89 e5                	mov    %esp,%ebp
77304803:	8b 45 08             	mov    0x8(%ebp),%eax
77304806:	85 c0                	test   %eax,%eax
77304808:	74 06                	je     77304810 <_ConsumeRegValueString+0x10>
7730480a:	5d                   	pop    %ebp
7730480b:	e9 10 37 00 00       	jmp    77307f20 <_free>
77304810:	5d                   	pop    %ebp
77304811:	c3                   	ret    
77304812:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
77304819:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77304820 <_QueryRegistryValueStringMulti>:
77304820:	55                   	push   %ebp
77304821:	31 c0                	xor    %eax,%eax
77304823:	89 e5                	mov    %esp,%ebp
77304825:	5d                   	pop    %ebp
77304826:	c3                   	ret    
77304827:	89 f6                	mov    %esi,%esi
77304829:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77304830 <_ConsumeRegValueStringMulti>:
77304830:	55                   	push   %ebp
77304831:	89 e5                	mov    %esp,%ebp
77304833:	53                   	push   %ebx
77304834:	50                   	push   %eax
77304835:	8b 5d 08             	mov    0x8(%ebp),%ebx
77304838:	85 db                	test   %ebx,%ebx
7730483a:	74 3e                	je     7730487a <_ConsumeRegValueStringMulti+0x4a>
7730483c:	8b 03                	mov    (%ebx),%eax
7730483e:	85 c0                	test   %eax,%eax
77304840:	75 0e                	jne    77304850 <_ConsumeRegValueStringMulti+0x20>
77304842:	89 5d 08             	mov    %ebx,0x8(%ebp)
77304845:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
77304848:	c9                   	leave  
77304849:	e9 d2 36 00 00       	jmp    77307f20 <_free>
7730484e:	89 f6                	mov    %esi,%esi
77304850:	83 ec 0c             	sub    $0xc,%esp
77304853:	8b 03                	mov    (%ebx),%eax
77304855:	50                   	push   %eax
77304856:	e8 c5 36 00 00       	call   77307f20 <_free>
7730485b:	8b 03                	mov    (%ebx),%eax
7730485d:	83 c4 10             	add    $0x10,%esp
77304860:	85 c0                	test   %eax,%eax
77304862:	74 de                	je     77304842 <_ConsumeRegValueStringMulti+0x12>
77304864:	83 ec 0c             	sub    $0xc,%esp
77304867:	8b 03                	mov    (%ebx),%eax
77304869:	50                   	push   %eax
7730486a:	e8 b1 36 00 00       	call   77307f20 <_free>
7730486f:	8b 03                	mov    (%ebx),%eax
77304871:	83 c4 10             	add    $0x10,%esp
77304874:	85 c0                	test   %eax,%eax
77304876:	75 d8                	jne    77304850 <_ConsumeRegValueStringMulti+0x20>
77304878:	eb c8                	jmp    77304842 <_ConsumeRegValueStringMulti+0x12>
7730487a:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
7730487d:	c9                   	leave  
7730487e:	c3                   	ret    
7730487f:	90                   	nop    

77304880 <_EnumInterfaces>:
77304880:	55                   	push   %ebp
77304881:	89 e5                	mov    %esp,%ebp
77304883:	57                   	push   %edi
77304884:	56                   	push   %esi
77304885:	53                   	push   %ebx
77304886:	83 ec 10             	sub    $0x10,%esp
77304889:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
7730488c:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
7730488f:	89 d7                	mov    %edx,%edi
77304891:	50                   	push   %eax
77304892:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
77304899:	68 f0 a3 30 77       	push   $0x7730a3f0
7730489e:	68 02 00 00 80       	push   $0x80000002
773048a3:	e8 28 fe ff ff       	call   773046d0 <_OpenChildKeyRead>
773048a8:	83 c4 10             	add    $0x10,%esp
773048ab:	85 c0                	test   %eax,%eax
773048ad:	75 57                	jne    77304906 <_EnumInterfaces+0x86>
773048af:	31 f6                	xor    %esi,%esi
773048b1:	eb 0d                	jmp    773048c0 <_EnumInterfaces+0x40>
773048b3:	83 ec 0c             	sub    $0xc,%esp
773048b6:	46                   	inc    %esi
773048b7:	53                   	push   %ebx
773048b8:	e8 b3 fe ff ff       	call   77304770 <_ConsumeChildKeyName>
773048bd:	83 c4 10             	add    $0x10,%esp
773048c0:	50                   	push   %eax
773048c1:	50                   	push   %eax
773048c2:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
773048c5:	56                   	push   %esi
773048c6:	50                   	push   %eax
773048c7:	e8 24 fe ff ff       	call   773046f0 <_GetNthChildKeyName>
773048cc:	83 c4 10             	add    $0x10,%esp
773048cf:	89 c3                	mov    %eax,%ebx
773048d1:	85 c0                	test   %eax,%eax
773048d3:	74 31                	je     77304906 <_EnumInterfaces+0x86>
773048d5:	50                   	push   %eax
773048d6:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
773048d9:	50                   	push   %eax
773048da:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
773048dd:	53                   	push   %ebx
773048de:	50                   	push   %eax
773048df:	e8 ec fd ff ff       	call   773046d0 <_OpenChildKeyRead>
773048e4:	83 c4 10             	add    $0x10,%esp
773048e7:	85 c0                	test   %eax,%eax
773048e9:	75 c8                	jne    773048b3 <_EnumInterfaces+0x33>
773048eb:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
773048ee:	50                   	push   %eax
773048ef:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
773048f2:	50                   	push   %eax
773048f3:	53                   	push   %ebx
773048f4:	51                   	push   %ecx
773048f5:	ff d7                	call   *%edi
773048f7:	5a                   	pop    %edx
773048f8:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
773048fb:	50                   	push   %eax
773048fc:	e8 cf 0a 00 00       	call   773053d0 <_RegCloseKey@4>
77304901:	83 c4 0c             	add    $0xc,%esp
77304904:	eb ad                	jmp    773048b3 <_EnumInterfaces+0x33>
77304906:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77304909:	5b                   	pop    %ebx
7730490a:	5e                   	pop    %esi
7730490b:	5f                   	pop    %edi
7730490c:	5d                   	pop    %ebp
7730490d:	c3                   	ret    
7730490e:	89 f6                	mov    %esi,%esi

77304910 <_EnumNameServers>:
77304910:	55                   	push   %ebp
77304911:	89 e5                	mov    %esp,%ebp
77304913:	57                   	push   %edi
77304914:	56                   	push   %esi
77304915:	53                   	push   %ebx
77304916:	83 ec 24             	sub    $0x24,%esp
77304919:	89 55 f0             	mov    %edx,0xfffffff0(%ebp)
7730491c:	8b 4d 0c             	mov    0xc(%ebp),%ecx
7730491f:	8b 55 08             	mov    0x8(%ebp),%edx
77304922:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
77304925:	89 4d e8             	mov    %ecx,0xffffffe8(%ebp)
77304928:	68 6c a4 30 77       	push   $0x7730a46c
7730492d:	50                   	push   %eax
7730492e:	e8 6d fe ff ff       	call   773047a0 <_QueryRegistryValueString>
77304933:	83 c4 10             	add    $0x10,%esp
77304936:	85 c0                	test   %eax,%eax
77304938:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
7730493b:	0f 84 e5 00 00 00    	je     77304a26 <_EnumNameServers+0x116>
77304941:	31 db                	xor    %ebx,%ebx
77304943:	66 8b 00             	mov    (%eax),%ax
77304946:	c7 45 e0 00 00 00 00 	movl   $0x0,0xffffffe0(%ebp)
7730494d:	eb 0a                	jmp    77304959 <_EnumNameServers+0x49>
7730494f:	90                   	nop    
77304950:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
77304953:	89 d3                	mov    %edx,%ebx
77304955:	66 8b 04 51          	mov    (%ecx,%edx,2),%ax
77304959:	66 85 c0             	test   %ax,%ax
7730495c:	74 6a                	je     773049c8 <_EnumNameServers+0xb8>
7730495e:	66 83 f8 2c          	cmp    $0x2c,%ax
77304962:	8d 53 01             	lea    0x1(%ebx),%edx
77304965:	75 e9                	jne    77304950 <_EnumNameServers+0x40>
77304967:	3b 5d e0             	cmp    0xffffffe0(%ebp),%ebx
7730496a:	74 54                	je     773049c0 <_EnumNameServers+0xb0>
7730496c:	8b 4d e0             	mov    0xffffffe0(%ebp),%ecx
7730496f:	89 df                	mov    %ebx,%edi
77304971:	29 cf                	sub    %ecx,%edi
77304973:	83 ec 0c             	sub    $0xc,%esp
77304976:	8d 47 01             	lea    0x1(%edi),%eax
77304979:	50                   	push   %eax
7730497a:	e8 c1 35 00 00       	call   77307f40 <_malloc>
7730497f:	83 c4 10             	add    $0x10,%esp
77304982:	89 c6                	mov    %eax,%esi
77304984:	85 c0                	test   %eax,%eax
77304986:	74 38                	je     773049c0 <_EnumNameServers+0xb0>
77304988:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
7730498b:	8b 4d e0             	mov    0xffffffe0(%ebp),%ecx
7730498e:	8d 04 4a             	lea    (%edx,%ecx,2),%eax
77304991:	52                   	push   %edx
77304992:	57                   	push   %edi
77304993:	50                   	push   %eax
77304994:	56                   	push   %esi
77304995:	e8 96 2f 00 00       	call   77307930 <_memcpy>
7730499a:	83 c4 0c             	add    $0xc,%esp
7730499d:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
773049a0:	66 c7 04 7e 00 00    	movw   $0x0,(%esi,%edi,2)
773049a6:	50                   	push   %eax
773049a7:	56                   	push   %esi
773049a8:	8b 7d f0             	mov    0xfffffff0(%ebp),%edi
773049ab:	57                   	push   %edi
773049ac:	ff 55 e8             	call   *0xffffffe8(%ebp)
773049af:	89 34 24             	mov    %esi,(%esp)
773049b2:	e8 69 35 00 00       	call   77307f20 <_free>
773049b7:	83 c4 10             	add    $0x10,%esp
773049ba:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
773049c0:	8d 53 01             	lea    0x1(%ebx),%edx
773049c3:	89 55 e0             	mov    %edx,0xffffffe0(%ebp)
773049c6:	eb 88                	jmp    77304950 <_EnumNameServers+0x40>
773049c8:	3b 5d e0             	cmp    0xffffffe0(%ebp),%ebx
773049cb:	74 47                	je     77304a14 <_EnumNameServers+0x104>
773049cd:	8b 75 e0             	mov    0xffffffe0(%ebp),%esi
773049d0:	83 ec 0c             	sub    $0xc,%esp
773049d3:	29 f3                	sub    %esi,%ebx
773049d5:	8d 43 01             	lea    0x1(%ebx),%eax
773049d8:	50                   	push   %eax
773049d9:	e8 62 35 00 00       	call   77307f40 <_malloc>
773049de:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
773049e1:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
773049e4:	83 c4 0c             	add    $0xc,%esp
773049e7:	89 c6                	mov    %eax,%esi
773049e9:	8d 04 51             	lea    (%ecx,%edx,2),%eax
773049ec:	53                   	push   %ebx
773049ed:	50                   	push   %eax
773049ee:	56                   	push   %esi
773049ef:	e8 3c 2f 00 00       	call   77307930 <_memcpy>
773049f4:	83 c4 0c             	add    $0xc,%esp
773049f7:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
773049fa:	66 c7 04 5e 00 00    	movw   $0x0,(%esi,%ebx,2)
77304a00:	51                   	push   %ecx
77304a01:	56                   	push   %esi
77304a02:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
77304a05:	52                   	push   %edx
77304a06:	ff 55 e8             	call   *0xffffffe8(%ebp)
77304a09:	89 34 24             	mov    %esi,(%esp)
77304a0c:	e8 0f 35 00 00       	call   77307f20 <_free>
77304a11:	83 c4 10             	add    $0x10,%esp
77304a14:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
77304a17:	89 45 08             	mov    %eax,0x8(%ebp)
77304a1a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77304a1d:	5b                   	pop    %ebx
77304a1e:	5e                   	pop    %esi
77304a1f:	5f                   	pop    %edi
77304a20:	5d                   	pop    %ebp
77304a21:	e9 da fd ff ff       	jmp    77304800 <_ConsumeRegValueString>
77304a26:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77304a29:	5b                   	pop    %ebx
77304a2a:	5e                   	pop    %esi
77304a2b:	5f                   	pop    %edi
77304a2c:	5d                   	pop    %ebp
77304a2d:	c3                   	ret    
77304a2e:	89 f6                	mov    %esi,%esi

77304a30 <_CreateNameServerListEnumNamesFuncCount>:
77304a30:	55                   	push   %ebp
77304a31:	89 e5                	mov    %esp,%ebp
77304a33:	8b 45 10             	mov    0x10(%ebp),%eax
77304a36:	8b 10                	mov    (%eax),%edx
77304a38:	42                   	inc    %edx
77304a39:	89 10                	mov    %edx,(%eax)
77304a3b:	5d                   	pop    %ebp
77304a3c:	c3                   	ret    
77304a3d:	8d 76 00             	lea    0x0(%esi),%esi

77304a40 <_CreateNameServerListEnumIfFuncCount>:
77304a40:	55                   	push   %ebp
77304a41:	89 e5                	mov    %esp,%ebp
77304a43:	8b 4d 10             	mov    0x10(%ebp),%ecx
77304a46:	8b 45 08             	mov    0x8(%ebp),%eax
77304a49:	8b 55 0c             	mov    0xc(%ebp),%edx
77304a4c:	89 4d 08             	mov    %ecx,0x8(%ebp)
77304a4f:	c7 45 0c 30 4a 30 77 	movl   $0x77304a30,0xc(%ebp)
77304a56:	5d                   	pop    %ebp
77304a57:	e9 b4 fe ff ff       	jmp    77304910 <_EnumNameServers>
77304a5c:	8d 74 26 00          	lea    0x0(%esi),%esi

77304a60 <_CreateNameServerListEnumNamesFunc>:
77304a60:	55                   	push   %ebp
77304a61:	89 e5                	mov    %esp,%ebp
77304a63:	56                   	push   %esi
77304a64:	53                   	push   %ebx
77304a65:	83 ec 0c             	sub    $0xc,%esp
77304a68:	8b 75 0c             	mov    0xc(%ebp),%esi
77304a6b:	8b 5d 10             	mov    0x10(%ebp),%ebx
77304a6e:	56                   	push   %esi
77304a6f:	e8 5c 2f 00 00       	call   773079d0 <_wcslen>
77304a74:	89 04 24             	mov    %eax,(%esp)
77304a77:	56                   	push   %esi
77304a78:	6a 00                	push   $0x0
77304a7a:	6a 10                	push   $0x10
77304a7c:	8b 43 04             	mov    0x4(%ebx),%eax
77304a7f:	8b 73 08             	mov    0x8(%ebx),%esi
77304a82:	c1 e0 04             	shl    $0x4,%eax
77304a85:	01 f0                	add    %esi,%eax
77304a87:	50                   	push   %eax
77304a88:	e8 e3 0e 00 00       	call   77305970 <_RtlUnicodeToMultiByteN@20>
77304a8d:	8b 4b 04             	mov    0x4(%ebx),%ecx
77304a90:	41                   	inc    %ecx
77304a91:	89 4b 04             	mov    %ecx,0x4(%ebx)
77304a94:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
77304a97:	5b                   	pop    %ebx
77304a98:	5e                   	pop    %esi
77304a99:	5d                   	pop    %ebp
77304a9a:	c3                   	ret    
77304a9b:	90                   	nop    
77304a9c:	8d 74 26 00          	lea    0x0(%esi),%esi

77304aa0 <_CreateNameServerListEnumIfFunc>:
77304aa0:	55                   	push   %ebp
77304aa1:	89 e5                	mov    %esp,%ebp
77304aa3:	8b 4d 10             	mov    0x10(%ebp),%ecx
77304aa6:	8b 45 08             	mov    0x8(%ebp),%eax
77304aa9:	8b 55 0c             	mov    0xc(%ebp),%edx
77304aac:	89 4d 08             	mov    %ecx,0x8(%ebp)
77304aaf:	c7 45 0c 60 4a 30 77 	movl   $0x77304a60,0xc(%ebp)
77304ab6:	5d                   	pop    %ebp
77304ab7:	e9 54 fe ff ff       	jmp    77304910 <_EnumNameServers>
77304abc:	8d 74 26 00          	lea    0x0(%esi),%esi

77304ac0 <_getResInfo>:
77304ac0:	55                   	push   %ebp
77304ac1:	31 c0                	xor    %eax,%eax
77304ac3:	89 e5                	mov    %esp,%ebp
77304ac5:	b9 03 00 00 00       	mov    $0x3,%ecx
77304aca:	fc                   	cld    
77304acb:	57                   	push   %edi
77304acc:	8d 7d a8             	lea    0xffffffa8(%ebp),%edi
77304acf:	56                   	push   %esi
77304ad0:	53                   	push   %ebx
77304ad1:	83 ec 6c             	sub    $0x6c,%esp
77304ad4:	ba 40 4a 30 77       	mov    $0x77304a40,%edx
77304ad9:	f3 ab                	repz stos %eax,%es:(%edi)
77304adb:	8d 45 a8             	lea    0xffffffa8(%ebp),%eax
77304ade:	e8 9d fd ff ff       	call   77304880 <_EnumInterfaces>
77304ae3:	8b 45 a8             	mov    0xffffffa8(%ebp),%eax
77304ae6:	83 ec 0c             	sub    $0xc,%esp
77304ae9:	89 45 a0             	mov    %eax,0xffffffa0(%ebp)
77304aec:	8d 45 a4             	lea    0xffffffa4(%ebp),%eax
77304aef:	50                   	push   %eax
77304af0:	68 19 00 02 00       	push   $0x20019
77304af5:	6a 00                	push   $0x0
77304af7:	68 84 a4 30 77       	push   $0x7730a484
77304afc:	68 02 00 00 80       	push   $0x80000002
77304b01:	e8 aa 08 00 00       	call   773053b0 <_RegOpenKeyExA@20>
77304b06:	83 c4 0c             	add    $0xc,%esp
77304b09:	85 c0                	test   %eax,%eax
77304b0b:	0f 85 59 01 00 00    	jne    77304c6a <_getResInfo+0x1aa>
77304b11:	53                   	push   %ebx
77304b12:	53                   	push   %ebx
77304b13:	68 6c a4 30 77       	push   $0x7730a46c
77304b18:	8b 4d a4             	mov    0xffffffa4(%ebp),%ecx
77304b1b:	51                   	push   %ecx
77304b1c:	e8 7f fc ff ff       	call   773047a0 <_QueryRegistryValueString>
77304b21:	83 c4 0c             	add    $0xc,%esp
77304b24:	89 c6                	mov    %eax,%esi
77304b26:	85 c0                	test   %eax,%eax
77304b28:	8b 55 a0             	mov    0xffffffa0(%ebp),%edx
77304b2b:	0f 95 c0             	setne  %al
77304b2e:	25 ff 00 00 00       	and    $0xff,%eax
77304b33:	01 c2                	add    %eax,%edx
77304b35:	89 45 9c             	mov    %eax,0xffffff9c(%ebp)
77304b38:	89 55 a0             	mov    %edx,0xffffffa0(%ebp)
77304b3b:	8b 55 a0             	mov    0xffffffa0(%ebp),%edx
77304b3e:	89 d3                	mov    %edx,%ebx
77304b40:	89 55 a8             	mov    %edx,0xffffffa8(%ebp)
77304b43:	c1 e3 04             	shl    $0x4,%ebx
77304b46:	53                   	push   %ebx
77304b47:	6a 00                	push   $0x0
77304b49:	57                   	push   %edi
77304b4a:	e8 e1 08 00 00       	call   77305430 <_GetProcessHeap@0>
77304b4f:	83 c3 08             	add    $0x8,%ebx
77304b52:	89 04 24             	mov    %eax,(%esp)
77304b55:	e8 a6 1d 00 00       	call   77306900 <_RtlAllocateHeap@12>
77304b5a:	89 45 b0             	mov    %eax,0xffffffb0(%ebp)
77304b5d:	53                   	push   %ebx
77304b5e:	6a 00                	push   $0x0
77304b60:	51                   	push   %ecx
77304b61:	e8 ca 08 00 00       	call   77305430 <_GetProcessHeap@0>
77304b66:	89 04 24             	mov    %eax,(%esp)
77304b69:	e8 92 1d 00 00       	call   77306900 <_RtlAllocateHeap@12>
77304b6e:	85 c0                	test   %eax,%eax
77304b70:	89 45 98             	mov    %eax,0xffffff98(%ebp)
77304b73:	5a                   	pop    %edx
77304b74:	0f 84 06 01 00 00    	je     77304c80 <_getResInfo+0x1c0>
77304b7a:	8b 45 98             	mov    0xffffff98(%ebp),%eax
77304b7d:	8b 55 a0             	mov    0xffffffa0(%ebp),%edx
77304b80:	89 c7                	mov    %eax,%edi
77304b82:	83 c7 08             	add    $0x8,%edi
77304b85:	89 10                	mov    %edx,(%eax)
77304b87:	89 78 04             	mov    %edi,0x4(%eax)
77304b8a:	ba a0 4a 30 77       	mov    $0x77304aa0,%edx
77304b8f:	8d 45 a8             	lea    0xffffffa8(%ebp),%eax
77304b92:	e8 e9 fc ff ff       	call   77304880 <_EnumInterfaces>
77304b97:	8b 4d 9c             	mov    0xffffff9c(%ebp),%ecx
77304b9a:	85 c9                	test   %ecx,%ecx
77304b9c:	74 49                	je     77304be7 <_getResInfo+0x127>
77304b9e:	31 d2                	xor    %edx,%edx
77304ba0:	66 8b 06             	mov    (%esi),%ax
77304ba3:	eb 09                	jmp    77304bae <_getResInfo+0xee>
77304ba5:	88 44 2a b8          	mov    %al,0xffffffb8(%edx,%ebp,1)
77304ba9:	42                   	inc    %edx
77304baa:	66 8b 04 56          	mov    (%esi,%edx,2),%ax
77304bae:	66 85 c0             	test   %ax,%ax
77304bb1:	75 f2                	jne    77304ba5 <_getResInfo+0xe5>
77304bb3:	c6 44 2a b8 00       	movb   $0x0,0xffffffb8(%edx,%ebp,1)
77304bb8:	83 ec 0c             	sub    $0xc,%esp
77304bbb:	8b 45 98             	mov    0xffffff98(%ebp),%eax
77304bbe:	8b 58 04             	mov    0x4(%eax),%ebx
77304bc1:	8d 45 b8             	lea    0xffffffb8(%ebp),%eax
77304bc4:	66 c7 03 02 00       	movw   $0x2,(%ebx)
77304bc9:	50                   	push   %eax
77304bca:	e8 21 2d 00 00       	call   773078f0 <_inet_addr@4>
77304bcf:	89 43 04             	mov    %eax,0x4(%ebx)
77304bd2:	8b 55 98             	mov    0xffffff98(%ebp),%edx
77304bd5:	8b 42 04             	mov    0x4(%edx),%eax
77304bd8:	66 c7 40 02 00 00    	movw   $0x0,0x2(%eax)
77304bde:	56                   	push   %esi
77304bdf:	e8 1c fc ff ff       	call   77304800 <_ConsumeRegValueString>
77304be4:	83 c4 10             	add    $0x10,%esp
77304be7:	8b 75 9c             	mov    0xffffff9c(%ebp),%esi
77304bea:	3b 75 a0             	cmp    0xffffffa0(%ebp),%esi
77304bed:	73 50                	jae    77304c3f <_getResInfo+0x17f>
77304bef:	8b 45 98             	mov    0xffffff98(%ebp),%eax
77304bf2:	c7 45 94 00 00 00 00 	movl   $0x0,0xffffff94(%ebp)
77304bf9:	8b 78 04             	mov    0x4(%eax),%edi
77304bfc:	8d 74 26 00          	lea    0x0(%esi),%esi
77304c00:	89 f3                	mov    %esi,%ebx
77304c02:	8b 55 b0             	mov    0xffffffb0(%ebp),%edx
77304c05:	c1 e3 04             	shl    $0x4,%ebx
77304c08:	83 ec 0c             	sub    $0xc,%esp
77304c0b:	8b 45 94             	mov    0xffffff94(%ebp),%eax
77304c0e:	46                   	inc    %esi
77304c0f:	01 d0                	add    %edx,%eax
77304c11:	66 c7 04 3b 02 00    	movw   $0x2,(%ebx,%edi,1)
77304c17:	50                   	push   %eax
77304c18:	e8 d3 2c 00 00       	call   773078f0 <_inet_addr@4>
77304c1d:	83 c4 0c             	add    $0xc,%esp
77304c20:	89 44 3b 04          	mov    %eax,0x4(%ebx,%edi,1)
77304c24:	8b 55 98             	mov    0xffffff98(%ebp),%edx
77304c27:	8b 45 94             	mov    0xffffff94(%ebp),%eax
77304c2a:	83 c0 10             	add    $0x10,%eax
77304c2d:	3b 75 a0             	cmp    0xffffffa0(%ebp),%esi
77304c30:	8b 7a 04             	mov    0x4(%edx),%edi
77304c33:	89 45 94             	mov    %eax,0xffffff94(%ebp)
77304c36:	66 c7 44 3b 02 00 00 	movw   $0x0,0x2(%ebx,%edi,1)
77304c3d:	72 c1                	jb     77304c00 <_getResInfo+0x140>
77304c3f:	50                   	push   %eax
77304c40:	8b 45 b0             	mov    0xffffffb0(%ebp),%eax
77304c43:	50                   	push   %eax
77304c44:	6a 00                	push   $0x0
77304c46:	50                   	push   %eax
77304c47:	e8 e4 07 00 00       	call   77305430 <_GetProcessHeap@0>
77304c4c:	89 04 24             	mov    %eax,(%esp)
77304c4f:	e8 fc 1d 00 00       	call   77306a50 <_RtlFreeHeap@12>
77304c54:	50                   	push   %eax
77304c55:	50                   	push   %eax
77304c56:	8b 7d a4             	mov    0xffffffa4(%ebp),%edi
77304c59:	57                   	push   %edi
77304c5a:	e8 71 07 00 00       	call   773053d0 <_RegCloseKey@4>
77304c5f:	8b 45 98             	mov    0xffffff98(%ebp),%eax
77304c62:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77304c65:	5b                   	pop    %ebx
77304c66:	5e                   	pop    %esi
77304c67:	5f                   	pop    %edi
77304c68:	5d                   	pop    %ebp
77304c69:	c3                   	ret    
77304c6a:	83 ec 0c             	sub    $0xc,%esp
77304c6d:	8b 5d a4             	mov    0xffffffa4(%ebp),%ebx
77304c70:	53                   	push   %ebx
77304c71:	e8 5a 07 00 00       	call   773053d0 <_RegCloseKey@4>
77304c76:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77304c79:	31 c0                	xor    %eax,%eax
77304c7b:	5b                   	pop    %ebx
77304c7c:	5e                   	pop    %esi
77304c7d:	5f                   	pop    %edi
77304c7e:	5d                   	pop    %ebp
77304c7f:	c3                   	ret    
77304c80:	50                   	push   %eax
77304c81:	8b 45 b0             	mov    0xffffffb0(%ebp),%eax
77304c84:	50                   	push   %eax
77304c85:	6a 00                	push   $0x0
77304c87:	57                   	push   %edi
77304c88:	e8 a3 07 00 00       	call   77305430 <_GetProcessHeap@0>
77304c8d:	89 04 24             	mov    %eax,(%esp)
77304c90:	e8 bb 1d 00 00       	call   77306a50 <_RtlFreeHeap@12>
77304c95:	56                   	push   %esi
77304c96:	56                   	push   %esi
77304c97:	eb d4                	jmp    77304c6d <_getResInfo+0x1ad>
77304c99:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

77304ca0 <_disposeResInfo>:
77304ca0:	55                   	push   %ebp
77304ca1:	89 e5                	mov    %esp,%ebp
77304ca3:	83 ec 0c             	sub    $0xc,%esp
77304ca6:	8b 45 08             	mov    0x8(%ebp),%eax
77304ca9:	50                   	push   %eax
77304caa:	6a 00                	push   $0x0
77304cac:	50                   	push   %eax
77304cad:	e8 7e 07 00 00       	call   77305430 <_GetProcessHeap@0>
77304cb2:	89 04 24             	mov    %eax,(%esp)
77304cb5:	e8 96 1d 00 00       	call   77306a50 <_RtlFreeHeap@12>
77304cba:	c9                   	leave  
77304cbb:	c3                   	ret    
77304cbc:	90                   	nop    
77304cbd:	90                   	nop    
77304cbe:	90                   	nop    
77304cbf:	90                   	nop    

77304cc0 <_createIpForwardEntry>:
77304cc0:	55                   	push   %ebp
77304cc1:	89 e5                	mov    %esp,%ebp
77304cc3:	57                   	push   %edi
77304cc4:	56                   	push   %esi
77304cc5:	53                   	push   %ebx
77304cc6:	81 ec 88 00 00 00    	sub    $0x88,%esp
77304ccc:	8d 45 94             	lea    0xffffff94(%ebp),%eax
77304ccf:	c7 45 94 ff ff ff ff 	movl   $0xffffffff,0xffffff94(%ebp)
77304cd6:	8b 75 08             	mov    0x8(%ebp),%esi
77304cd9:	50                   	push   %eax
77304cda:	e8 11 c5 ff ff       	call   773011f0 <_openTcpFile>
77304cdf:	83 c4 0c             	add    $0xc,%esp
77304ce2:	8d 7d 98             	lea    0xffffff98(%ebp),%edi
77304ce5:	89 c3                	mov    %eax,%ebx
77304ce7:	6a 50                	push   $0x50
77304ce9:	6a 00                	push   $0x0
77304ceb:	57                   	push   %edi
77304cec:	e8 9f 2c 00 00       	call   77307990 <_memset>
77304cf1:	83 c4 10             	add    $0x10,%esp
77304cf4:	c7 45 84 00 00 00 00 	movl   $0x0,0xffffff84(%ebp)
77304cfb:	85 db                	test   %ebx,%ebx
77304cfd:	0f 88 aa 00 00 00    	js     77304dad <_createIpForwardEntry+0xed>
77304d03:	8d 45 88             	lea    0xffffff88(%ebp),%eax
77304d06:	51                   	push   %ecx
77304d07:	50                   	push   %eax
77304d08:	6a 00                	push   $0x0
77304d0a:	8b 55 94             	mov    0xffffff94(%ebp),%edx
77304d0d:	52                   	push   %edx
77304d0e:	e8 cd d3 ff ff       	call   773020e0 <_getNthIpEntity>
77304d13:	83 c4 10             	add    $0x10,%esp
77304d16:	89 c3                	mov    %eax,%ebx
77304d18:	85 c0                	test   %eax,%eax
77304d1a:	0f 88 8d 00 00 00    	js     77304dad <_createIpForwardEntry+0xed>
77304d20:	8b 45 88             	mov    0xffffff88(%ebp),%eax
77304d23:	8b 55 8c             	mov    0xffffff8c(%ebp),%edx
77304d26:	89 55 9c             	mov    %edx,0xffffff9c(%ebp)
77304d29:	c7 45 a0 00 02 00 00 	movl   $0x200,0xffffffa0(%ebp)
77304d30:	c7 45 a4 00 01 00 00 	movl   $0x100,0xffffffa4(%ebp)
77304d37:	c7 45 a8 01 01 00 00 	movl   $0x101,0xffffffa8(%ebp)
77304d3e:	89 45 98             	mov    %eax,0xffffff98(%ebp)
77304d41:	c7 45 ac 34 00 00 00 	movl   $0x34,0xffffffac(%ebp)
77304d48:	8b 06                	mov    (%esi),%eax
77304d4a:	89 45 b0             	mov    %eax,0xffffffb0(%ebp)
77304d4d:	8b 46 04             	mov    0x4(%esi),%eax
77304d50:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
77304d53:	8b 46 0c             	mov    0xc(%esi),%eax
77304d56:	89 45 c8             	mov    %eax,0xffffffc8(%ebp)
77304d59:	8b 46 10             	mov    0x10(%esi),%eax
77304d5c:	c7 45 cc 03 00 00 00 	movl   $0x3,0xffffffcc(%ebp)
77304d63:	89 45 b4             	mov    %eax,0xffffffb4(%ebp)
77304d66:	8b 46 18             	mov    0x18(%esi),%eax
77304d69:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
77304d6c:	8b 46 1c             	mov    0x1c(%esi),%eax
77304d6f:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
77304d72:	8b 46 24             	mov    0x24(%esi),%eax
77304d75:	89 45 b8             	mov    %eax,0xffffffb8(%ebp)
77304d78:	8b 46 28             	mov    0x28(%esi),%eax
77304d7b:	89 45 bc             	mov    %eax,0xffffffbc(%ebp)
77304d7e:	8b 46 2c             	mov    0x2c(%esi),%eax
77304d81:	89 45 c0             	mov    %eax,0xffffffc0(%ebp)
77304d84:	8b 46 30             	mov    0x30(%esi),%eax
77304d87:	89 45 c4             	mov    %eax,0xffffffc4(%ebp)
77304d8a:	8b 46 34             	mov    0x34(%esi),%eax
77304d8d:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
77304d90:	8d 45 84             	lea    0xffffff84(%ebp),%eax
77304d93:	6a 00                	push   $0x0
77304d95:	50                   	push   %eax
77304d96:	6a 00                	push   $0x0
77304d98:	6a 00                	push   $0x0
77304d9a:	6a 50                	push   $0x50
77304d9c:	57                   	push   %edi
77304d9d:	68 04 80 12 00       	push   $0x128004
77304da2:	8b 45 94             	mov    0xffffff94(%ebp),%eax
77304da5:	50                   	push   %eax
77304da6:	e8 75 06 00 00       	call   77305420 <_DeviceIoControl@32>
77304dab:	89 c3                	mov    %eax,%ebx
                                  NULL );
    }

    if( tcpFile != INVALID_HANDLE_VALUE )
77304dad:	8b 45 94             	mov    0xffffff94(%ebp),%eax
77304db0:	83 f8 ff             	cmp    $0xffffffff,%eax
77304db3:	74 0c                	je     77304dc1 <_createIpForwardEntry+0x101>
        closeTcpFile( tcpFile );
77304db5:	83 ec 0c             	sub    $0xc,%esp
77304db8:	50                   	push   %eax
77304db9:	e8 a2 c4 ff ff       	call   77301260 <_closeTcpFile>
77304dbe:	83 c4 10             	add    $0x10,%esp

    DPRINT("Returning: %08x (IOCTL was %08x)\n", status, IOCTL_TCP_SET_INFORMATION_EX);

    if( NT_SUCCESS(status) )
	return NO_ERROR;
77304dc1:	31 c0                	xor    %eax,%eax
77304dc3:	85 db                	test   %ebx,%ebx
77304dc5:	78 09                	js     77304dd0 <_createIpForwardEntry+0x110>
    else
	return status;
}
77304dc7:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77304dca:	5b                   	pop    %ebx
77304dcb:	5e                   	pop    %esi
77304dcc:	5f                   	pop    %edi
77304dcd:	5d                   	pop    %ebp
77304dce:	c3                   	ret    
77304dcf:	90                   	nop    
77304dd0:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77304dd3:	89 d8                	mov    %ebx,%eax
77304dd5:	5b                   	pop    %ebx
77304dd6:	5e                   	pop    %esi
77304dd7:	5f                   	pop    %edi
77304dd8:	5d                   	pop    %ebp
77304dd9:	c3                   	ret    
77304dda:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

77304de0 <_setIpForwardEntry>:

DWORD setIpForwardEntry( PMIB_IPFORWARDROW pRoute ) {
77304de0:	55                   	push   %ebp
77304de1:	89 e5                	mov    %esp,%ebp
77304de3:	50                   	push   %eax
77304de4:	50                   	push   %eax
    FIXME(":stub\n");
77304de5:	68 c0 a4 30 77       	push   $0x7730a4c0
77304dea:	6a 73                	push   $0x73
77304dec:	68 d2 a4 30 77       	push   $0x7730a4d2
77304df1:	68 e2 a4 30 77       	push   $0x7730a4e2
77304df6:	e8 85 2b 00 00       	call   77307980 <_DbgPrint>
77304dfb:	c7 04 24 ee a4 30 77 	movl   $0x7730a4ee,(%esp)
77304e02:	e8 79 2b 00 00       	call   77307980 <_DbgPrint>
    return (DWORD) 0;
}
77304e07:	31 c0                	xor    %eax,%eax
77304e09:	c9                   	leave  
77304e0a:	c3                   	ret    
77304e0b:	90                   	nop    
77304e0c:	8d 74 26 00          	lea    0x0(%esi),%esi

77304e10 <_deleteIpForwardEntry>:

DWORD deleteIpForwardEntry( PMIB_IPFORWARDROW pRoute ) {
77304e10:	55                   	push   %ebp
77304e11:	89 e5                	mov    %esp,%ebp
77304e13:	57                   	push   %edi
77304e14:	56                   	push   %esi
77304e15:	53                   	push   %ebx
77304e16:	81 ec 88 00 00 00    	sub    $0x88,%esp
    HANDLE tcpFile = INVALID_HANDLE_VALUE;
    NTSTATUS status = openTcpFile( &tcpFile );
77304e1c:	8d 45 94             	lea    0xffffff94(%ebp),%eax
77304e1f:	c7 45 94 ff ff ff ff 	movl   $0xffffffff,0xffffff94(%ebp)
77304e26:	8b 75 08             	mov    0x8(%ebp),%esi
77304e29:	50                   	push   %eax
77304e2a:	e8 c1 c3 ff ff       	call   773011f0 <_openTcpFile>
    TCP_REQUEST_SET_INFORMATION_EX_SAFELY_SIZED req = 
77304e2f:	83 c4 0c             	add    $0xc,%esp
77304e32:	8d 7d 98             	lea    0xffffff98(%ebp),%edi
77304e35:	89 c3                	mov    %eax,%ebx
77304e37:	6a 50                	push   $0x50
77304e39:	6a 00                	push   $0x0
77304e3b:	57                   	push   %edi
77304e3c:	e8 4f 2b 00 00       	call   77307990 <_memset>
        TCP_REQUEST_SET_INFORMATION_INIT;
    IPRouteEntry *rte;
    TDIEntityID   id;
    DWORD         returnSize = 0;
    
    DPRINT("Called.\n");

    if( NT_SUCCESS(status) )
77304e41:	83 c4 10             	add    $0x10,%esp
77304e44:	c7 45 84 00 00 00 00 	movl   $0x0,0xffffff84(%ebp)
77304e4b:	85 db                	test   %ebx,%ebx
77304e4d:	0f 88 af 00 00 00    	js     77304f02 <_deleteIpForwardEntry+0xf2>
        status = getNthIpEntity( tcpFile, 0, &id );
77304e53:	50                   	push   %eax
77304e54:	8d 45 88             	lea    0xffffff88(%ebp),%eax
77304e57:	50                   	push   %eax
77304e58:	6a 00                	push   $0x0
77304e5a:	8b 45 94             	mov    0xffffff94(%ebp),%eax
77304e5d:	50                   	push   %eax
77304e5e:	e8 7d d2 ff ff       	call   773020e0 <_getNthIpEntity>
77304e63:	83 c4 10             	add    $0x10,%esp
77304e66:	89 c3                	mov    %eax,%ebx

    if( NT_SUCCESS(status) ) {
77304e68:	85 c0                	test   %eax,%eax
77304e6a:	0f 88 92 00 00 00    	js     77304f02 <_deleteIpForwardEntry+0xf2>
        req.Req.ID.toi_class                = INFO_CLASS_PROTOCOL;
        req.Req.ID.toi_type                 = INFO_TYPE_PROVIDER;
        req.Req.ID.toi_id                   = IP_MIB_ROUTETABLE_ENTRY_ID;
        req.Req.ID.toi_entity               = id;
77304e70:	8b 45 88             	mov    0xffffff88(%ebp),%eax
77304e73:	8b 55 8c             	mov    0xffffff8c(%ebp),%edx
77304e76:	89 55 9c             	mov    %edx,0xffffff9c(%ebp)
77304e79:	c7 45 a0 00 02 00 00 	movl   $0x200,0xffffffa0(%ebp)
77304e80:	c7 45 a4 00 01 00 00 	movl   $0x100,0xffffffa4(%ebp)
77304e87:	c7 45 a8 01 01 00 00 	movl   $0x101,0xffffffa8(%ebp)
77304e8e:	89 45 98             	mov    %eax,0xffffff98(%ebp)
        req.Req.BufferSize                  = sizeof(*rte);
77304e91:	c7 45 ac 34 00 00 00 	movl   $0x34,0xffffffac(%ebp)
        rte                                 = 
            (IPRouteEntry *)&req.Req.Buffer[0];

	// dwForwardPolicy
	// dwForwardNextHopAS
	rte->ire_dest    = pRoute->dwForwardDest;
77304e98:	8b 06                	mov    (%esi),%eax
	rte->ire_mask    = INADDR_NONE;
77304e9a:	c7 45 d8 ff ff ff ff 	movl   $0xffffffff,0xffffffd8(%ebp)
77304ea1:	89 45 b0             	mov    %eax,0xffffffb0(%ebp)
	rte->ire_gw      = pRoute->dwForwardNextHop;
77304ea4:	8b 46 0c             	mov    0xc(%esi),%eax
77304ea7:	89 45 c8             	mov    %eax,0xffffffc8(%ebp)
	rte->ire_index   = pRoute->dwForwardIfIndex;
77304eaa:	8b 46 10             	mov    0x10(%esi),%eax
	rte->ire_type    = IP_FORWARD_DEL;
77304ead:	c7 45 cc 02 00 00 00 	movl   $0x2,0xffffffcc(%ebp)
77304eb4:	89 45 b4             	mov    %eax,0xffffffb4(%ebp)
	rte->ire_proto   = pRoute->dwForwardProto;
77304eb7:	8b 46 18             	mov    0x18(%esi),%eax
77304eba:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
	rte->ire_age     = pRoute->dwForwardAge;
77304ebd:	8b 46 1c             	mov    0x1c(%esi),%eax
77304ec0:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
	rte->ire_metric1 = pRoute->dwForwardMetric1;
77304ec3:	8b 46 24             	mov    0x24(%esi),%eax
	rte->ire_metric2 = INADDR_NONE;
77304ec6:	c7 45 bc ff ff ff ff 	movl   $0xffffffff,0xffffffbc(%ebp)
77304ecd:	89 45 b8             	mov    %eax,0xffffffb8(%ebp)
	rte->ire_metric3 = INADDR_NONE;
	rte->ire_metric4 = INADDR_NONE;
	rte->ire_metric5 = INADDR_NONE;

        status = DeviceIoControl( tcpFile,
77304ed0:	8d 45 84             	lea    0xffffff84(%ebp),%eax
77304ed3:	c7 45 c0 ff ff ff ff 	movl   $0xffffffff,0xffffffc0(%ebp)
77304eda:	c7 45 c4 ff ff ff ff 	movl   $0xffffffff,0xffffffc4(%ebp)
77304ee1:	c7 45 dc ff ff ff ff 	movl   $0xffffffff,0xffffffdc(%ebp)
77304ee8:	6a 00                	push   $0x0
77304eea:	50                   	push   %eax
77304eeb:	6a 00                	push   $0x0
77304eed:	6a 00                	push   $0x0
77304eef:	6a 50                	push   $0x50
77304ef1:	57                   	push   %edi
77304ef2:	68 04 80 12 00       	push   $0x128004
77304ef7:	8b 45 94             	mov    0xffffff94(%ebp),%eax
77304efa:	50                   	push   %eax
77304efb:	e8 20 05 00 00       	call   77305420 <_DeviceIoControl@32>
77304f00:	89 c3                	mov    %eax,%ebx
                                  IOCTL_TCP_SET_INFORMATION_EX,
                                  &req,
                                  sizeof(req),
                                  NULL,
                                  0,
                                  &returnSize,
                                  NULL );
    }

    if( tcpFile != INVALID_HANDLE_VALUE )
77304f02:	8b 45 94             	mov    0xffffff94(%ebp),%eax
77304f05:	83 f8 ff             	cmp    $0xffffffff,%eax
77304f08:	74 0c                	je     77304f16 <_deleteIpForwardEntry+0x106>
        closeTcpFile( tcpFile );
77304f0a:	83 ec 0c             	sub    $0xc,%esp
77304f0d:	50                   	push   %eax
77304f0e:	e8 4d c3 ff ff       	call   77301260 <_closeTcpFile>
77304f13:	83 c4 10             	add    $0x10,%esp

    DPRINT("Returning: %08x (IOCTL was %08x)\n", status, IOCTL_TCP_SET_INFORMATION_EX);

    if( NT_SUCCESS(status) )
	return NO_ERROR;
77304f16:	31 c0                	xor    %eax,%eax
77304f18:	85 db                	test   %ebx,%ebx
77304f1a:	78 08                	js     77304f24 <_deleteIpForwardEntry+0x114>
    else
	return status;
}
77304f1c:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77304f1f:	5b                   	pop    %ebx
77304f20:	5e                   	pop    %esi
77304f21:	5f                   	pop    %edi
77304f22:	5d                   	pop    %ebp
77304f23:	c3                   	ret    
77304f24:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77304f27:	89 d8                	mov    %ebx,%eax
77304f29:	5b                   	pop    %ebx
77304f2a:	5e                   	pop    %esi
77304f2b:	5f                   	pop    %edi
77304f2c:	5d                   	pop    %ebp
77304f2d:	c3                   	ret    
77304f2e:	90                   	nop    
77304f2f:	90                   	nop    

77304f30 <___wine_unimplemented>:
77304f30:	55                   	push   %ebp
77304f31:	89 e5                	mov    %esp,%ebp
77304f33:	53                   	push   %ebx
77304f34:	83 ec 54             	sub    $0x54,%esp
77304f37:	89 45 c0             	mov    %eax,0xffffffc0(%ebp)
77304f3a:	8b 45 00             	mov    0x0(%ebp),%eax
77304f3d:	c7 45 a8 00 01 00 80 	movl   $0x80000100,0xffffffa8(%ebp)
77304f44:	c7 45 ac 01 00 00 00 	movl   $0x1,0xffffffac(%ebp)
77304f4b:	c7 45 b0 00 00 00 00 	movl   $0x0,0xffffffb0(%ebp)
77304f52:	c7 45 b8 02 00 00 00 	movl   $0x2,0xffffffb8(%ebp)
77304f59:	c7 45 bc 00 a5 30 77 	movl   $0x7730a500,0xffffffbc(%ebp)
77304f60:	8d 5d a8             	lea    0xffffffa8(%ebp),%ebx
77304f63:	8b 40 04             	mov    0x4(%eax),%eax
77304f66:	89 45 b4             	mov    %eax,0xffffffb4(%ebp)
77304f69:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
77304f70:	83 ec 0c             	sub    $0xc,%esp
77304f73:	53                   	push   %ebx
77304f74:	e8 c7 22 00 00       	call   77307240 <_RtlRaiseException@4>
77304f79:	83 c4 0c             	add    $0xc,%esp
77304f7c:	eb f2                	jmp    77304f70 <___wine_unimplemented+0x40>
77304f7e:	89 f6                	mov    %esi,%esi

77304f80 <___wine_stub_iphlpapi_dll_2>:
77304f80:	55                   	push   %ebp
77304f81:	89 e5                	mov    %esp,%ebp
77304f83:	50                   	push   %eax
77304f84:	50                   	push   %eax
77304f85:	b8 10 a5 30 77       	mov    $0x7730a510,%eax
77304f8a:	e8 a1 ff ff ff       	call   77304f30 <___wine_unimplemented>
77304f8f:	90                   	nop    

77304f90 <___wine_stub_iphlpapi_dll_18>:
77304f90:	55                   	push   %ebp
77304f91:	b8 33 a5 30 77       	mov    $0x7730a533,%eax
77304f96:	89 e5                	mov    %esp,%ebp
77304f98:	52                   	push   %edx
77304f99:	52                   	push   %edx
77304f9a:	e8 91 ff ff ff       	call   77304f30 <___wine_unimplemented>
77304f9f:	90                   	nop    

77304fa0 <___wine_stub_iphlpapi_dll_20>:
77304fa0:	55                   	push   %ebp
77304fa1:	b8 4c a5 30 77       	mov    $0x7730a54c,%eax
77304fa6:	89 e5                	mov    %esp,%ebp
77304fa8:	51                   	push   %ecx
77304fa9:	51                   	push   %ecx
77304faa:	e8 81 ff ff ff       	call   77304f30 <___wine_unimplemented>
77304faf:	90                   	nop    

77304fb0 <___wine_stub_iphlpapi_dll_23>:
77304fb0:	55                   	push   %ebp
77304fb1:	89 e5                	mov    %esp,%ebp
77304fb3:	50                   	push   %eax
77304fb4:	50                   	push   %eax
77304fb5:	b8 5f a5 30 77       	mov    $0x7730a55f,%eax
77304fba:	e8 71 ff ff ff       	call   77304f30 <___wine_unimplemented>
77304fbf:	90                   	nop    

77304fc0 <___wine_stub_iphlpapi_dll_25>:
77304fc0:	55                   	push   %ebp
77304fc1:	89 e5                	mov    %esp,%ebp
77304fc3:	50                   	push   %eax
77304fc4:	50                   	push   %eax
77304fc5:	b8 79 a5 30 77       	mov    $0x7730a579,%eax
77304fca:	e8 61 ff ff ff       	call   77304f30 <___wine_unimplemented>
77304fcf:	90                   	nop    

77304fd0 <___wine_stub_iphlpapi_dll_28>:
77304fd0:	55                   	push   %ebp
77304fd1:	89 e5                	mov    %esp,%ebp
77304fd3:	50                   	push   %eax
77304fd4:	50                   	push   %eax
77304fd5:	b8 8f a5 30 77       	mov    $0x7730a58f,%eax
77304fda:	e8 51 ff ff ff       	call   77304f30 <___wine_unimplemented>
77304fdf:	90                   	nop    

77304fe0 <___wine_stub_iphlpapi_dll_30>:
77304fe0:	55                   	push   %ebp
77304fe1:	89 e5                	mov    %esp,%ebp
77304fe3:	50                   	push   %eax
77304fe4:	50                   	push   %eax
77304fe5:	b8 a5 a5 30 77       	mov    $0x7730a5a5,%eax
77304fea:	e8 41 ff ff ff       	call   77304f30 <___wine_unimplemented>
77304fef:	90                   	nop    

77304ff0 <___wine_stub_iphlpapi_dll_32>:
77304ff0:	55                   	push   %ebp
77304ff1:	89 e5                	mov    %esp,%ebp
77304ff3:	50                   	push   %eax
77304ff4:	50                   	push   %eax
77304ff5:	b8 b9 a5 30 77       	mov    $0x7730a5b9,%eax
77304ffa:	e8 31 ff ff ff       	call   77304f30 <___wine_unimplemented>
77304fff:	90                   	nop    

77305000 <___wine_stub_iphlpapi_dll_33>:
77305000:	55                   	push   %ebp
77305001:	89 e5                	mov    %esp,%ebp
77305003:	50                   	push   %eax
77305004:	50                   	push   %eax
77305005:	b8 cd a5 30 77       	mov    $0x7730a5cd,%eax
7730500a:	e8 21 ff ff ff       	call   77304f30 <___wine_unimplemented>
7730500f:	90                   	nop    

77305010 <___wine_stub_iphlpapi_dll_36>:
77305010:	55                   	push   %ebp
77305011:	b8 d9 a5 30 77       	mov    $0x7730a5d9,%eax
77305016:	89 e5                	mov    %esp,%ebp
77305018:	52                   	push   %edx
77305019:	52                   	push   %edx
7730501a:	e8 11 ff ff ff       	call   77304f30 <___wine_unimplemented>
7730501f:	90                   	nop    

77305020 <___wine_stub_iphlpapi_dll_38>:
77305020:	55                   	push   %ebp
77305021:	b8 f1 a5 30 77       	mov    $0x7730a5f1,%eax
77305026:	89 e5                	mov    %esp,%ebp
77305028:	51                   	push   %ecx
77305029:	51                   	push   %ecx
7730502a:	e8 01 ff ff ff       	call   77304f30 <___wine_unimplemented>
7730502f:	90                   	nop    

77305030 <___wine_stub_iphlpapi_dll_40>:
77305030:	55                   	push   %ebp
77305031:	89 e5                	mov    %esp,%ebp
77305033:	50                   	push   %eax
77305034:	50                   	push   %eax
77305035:	b8 0c a6 30 77       	mov    $0x7730a60c,%eax
7730503a:	e8 f1 fe ff ff       	call   77304f30 <___wine_unimplemented>
7730503f:	90                   	nop    

77305040 <___wine_stub_iphlpapi_dll_42>:
77305040:	55                   	push   %ebp
77305041:	89 e5                	mov    %esp,%ebp
77305043:	50                   	push   %eax
77305044:	50                   	push   %eax
77305045:	b8 23 a6 30 77       	mov    $0x7730a623,%eax
7730504a:	e8 e1 fe ff ff       	call   77304f30 <___wine_unimplemented>
7730504f:	90                   	nop    

77305050 <___wine_stub_iphlpapi_dll_48>:
77305050:	55                   	push   %ebp
77305051:	89 e5                	mov    %esp,%ebp
77305053:	50                   	push   %eax
77305054:	50                   	push   %eax
77305055:	b8 37 a6 30 77       	mov    $0x7730a637,%eax
7730505a:	e8 d1 fe ff ff       	call   77304f30 <___wine_unimplemented>
7730505f:	90                   	nop    

77305060 <___wine_stub_iphlpapi_dll_50>:
77305060:	55                   	push   %ebp
77305061:	89 e5                	mov    %esp,%ebp
77305063:	50                   	push   %eax
77305064:	50                   	push   %eax
77305065:	b8 4c a6 30 77       	mov    $0x7730a64c,%eax
7730506a:	e8 c1 fe ff ff       	call   77304f30 <___wine_unimplemented>
7730506f:	90                   	nop    

77305070 <___wine_stub_iphlpapi_dll_52>:
77305070:	55                   	push   %ebp
77305071:	89 e5                	mov    %esp,%ebp
77305073:	50                   	push   %eax
77305074:	50                   	push   %eax
77305075:	b8 61 a6 30 77       	mov    $0x7730a661,%eax
7730507a:	e8 b1 fe ff ff       	call   77304f30 <___wine_unimplemented>
7730507f:	90                   	nop    

77305080 <___wine_stub_iphlpapi_dll_54>:
77305080:	55                   	push   %ebp
77305081:	89 e5                	mov    %esp,%ebp
77305083:	50                   	push   %eax
77305084:	50                   	push   %eax
77305085:	b8 76 a6 30 77       	mov    $0x7730a676,%eax
7730508a:	e8 a1 fe ff ff       	call   77304f30 <___wine_unimplemented>
7730508f:	90                   	nop    

77305090 <___wine_stub_iphlpapi_dll_56>:
77305090:	55                   	push   %ebp
77305091:	b8 8b a6 30 77       	mov    $0x7730a68b,%eax
77305096:	89 e5                	mov    %esp,%ebp
77305098:	52                   	push   %edx
77305099:	52                   	push   %edx
7730509a:	e8 91 fe ff ff       	call   77304f30 <___wine_unimplemented>
7730509f:	90                   	nop    

773050a0 <___wine_stub_iphlpapi_dll_57>:
773050a0:	55                   	push   %ebp
773050a1:	b8 a8 a6 30 77       	mov    $0x7730a6a8,%eax
773050a6:	89 e5                	mov    %esp,%ebp
773050a8:	51                   	push   %ecx
773050a9:	51                   	push   %ecx
773050aa:	e8 81 fe ff ff       	call   77304f30 <___wine_unimplemented>
773050af:	90                   	nop    

773050b0 <___wine_stub_iphlpapi_dll_58>:
773050b0:	55                   	push   %ebp
773050b1:	89 e5                	mov    %esp,%ebp
773050b3:	50                   	push   %eax
773050b4:	50                   	push   %eax
773050b5:	b8 c1 a6 30 77       	mov    $0x7730a6c1,%eax
773050ba:	e8 71 fe ff ff       	call   77304f30 <___wine_unimplemented>
773050bf:	90                   	nop    

773050c0 <___wine_stub_iphlpapi_dll_59>:
773050c0:	55                   	push   %ebp
773050c1:	89 e5                	mov    %esp,%ebp
773050c3:	50                   	push   %eax
773050c4:	50                   	push   %eax
773050c5:	b8 de a6 30 77       	mov    $0x7730a6de,%eax
773050ca:	e8 61 fe ff ff       	call   77304f30 <___wine_unimplemented>
773050cf:	90                   	nop    

773050d0 <___wine_stub_iphlpapi_dll_60>:
773050d0:	55                   	push   %ebp
773050d1:	89 e5                	mov    %esp,%ebp
773050d3:	50                   	push   %eax
773050d4:	50                   	push   %eax
773050d5:	b8 f7 a6 30 77       	mov    $0x7730a6f7,%eax
773050da:	e8 51 fe ff ff       	call   77304f30 <___wine_unimplemented>
773050df:	90                   	nop    

773050e0 <___wine_stub_iphlpapi_dll_61>:
773050e0:	55                   	push   %ebp
773050e1:	89 e5                	mov    %esp,%ebp
773050e3:	50                   	push   %eax
773050e4:	50                   	push   %eax
773050e5:	b8 0a a7 30 77       	mov    $0x7730a70a,%eax
773050ea:	e8 41 fe ff ff       	call   77304f30 <___wine_unimplemented>
773050ef:	90                   	nop    

773050f0 <___wine_stub_iphlpapi_dll_62>:
773050f0:	55                   	push   %ebp
773050f1:	89 e5                	mov    %esp,%ebp
773050f3:	50                   	push   %eax
773050f4:	50                   	push   %eax
773050f5:	b8 21 a7 30 77       	mov    $0x7730a721,%eax
773050fa:	e8 31 fe ff ff       	call   77304f30 <___wine_unimplemented>
773050ff:	90                   	nop    

77305100 <___wine_stub_iphlpapi_dll_63>:
77305100:	55                   	push   %ebp
77305101:	89 e5                	mov    %esp,%ebp
77305103:	50                   	push   %eax
77305104:	50                   	push   %eax
77305105:	b8 3b a7 30 77       	mov    $0x7730a73b,%eax
7730510a:	e8 21 fe ff ff       	call   77304f30 <___wine_unimplemented>
7730510f:	90                   	nop    

77305110 <___wine_stub_iphlpapi_dll_64>:
77305110:	55                   	push   %ebp
77305111:	b8 51 a7 30 77       	mov    $0x7730a751,%eax
77305116:	89 e5                	mov    %esp,%ebp
77305118:	52                   	push   %edx
77305119:	52                   	push   %edx
7730511a:	e8 11 fe ff ff       	call   77304f30 <___wine_unimplemented>
7730511f:	90                   	nop    

77305120 <___wine_stub_iphlpapi_dll_65>:
77305120:	55                   	push   %ebp
77305121:	b8 65 a7 30 77       	mov    $0x7730a765,%eax
77305126:	89 e5                	mov    %esp,%ebp
77305128:	51                   	push   %ecx
77305129:	51                   	push   %ecx
7730512a:	e8 01 fe ff ff       	call   77304f30 <___wine_unimplemented>
7730512f:	90                   	nop    

77305130 <___wine_stub_iphlpapi_dll_66>:
77305130:	55                   	push   %ebp
77305131:	89 e5                	mov    %esp,%ebp
77305133:	50                   	push   %eax
77305134:	50                   	push   %eax
77305135:	b8 79 a7 30 77       	mov    $0x7730a779,%eax
7730513a:	e8 f1 fd ff ff       	call   77304f30 <___wine_unimplemented>
7730513f:	90                   	nop    

77305140 <___wine_stub_iphlpapi_dll_67>:
77305140:	55                   	push   %ebp
77305141:	89 e5                	mov    %esp,%ebp
77305143:	50                   	push   %eax
77305144:	50                   	push   %eax
77305145:	b8 8c a7 30 77       	mov    $0x7730a78c,%eax
7730514a:	e8 e1 fd ff ff       	call   77304f30 <___wine_unimplemented>
7730514f:	90                   	nop    

77305150 <___wine_stub_iphlpapi_dll_68>:
77305150:	55                   	push   %ebp
77305151:	89 e5                	mov    %esp,%ebp
77305153:	50                   	push   %eax
77305154:	50                   	push   %eax
77305155:	b8 a6 a7 30 77       	mov    $0x7730a7a6,%eax
7730515a:	e8 d1 fd ff ff       	call   77304f30 <___wine_unimplemented>
7730515f:	90                   	nop    

77305160 <___wine_stub_iphlpapi_dll_69>:
77305160:	55                   	push   %ebp
77305161:	89 e5                	mov    %esp,%ebp
77305163:	50                   	push   %eax
77305164:	50                   	push   %eax
77305165:	b8 bc a7 30 77       	mov    $0x7730a7bc,%eax
7730516a:	e8 c1 fd ff ff       	call   77304f30 <___wine_unimplemented>
7730516f:	90                   	nop    

77305170 <___wine_stub_iphlpapi_dll_70>:
77305170:	55                   	push   %ebp
77305171:	89 e5                	mov    %esp,%ebp
77305173:	50                   	push   %eax
77305174:	50                   	push   %eax
77305175:	b8 cf a7 30 77       	mov    $0x7730a7cf,%eax
7730517a:	e8 b1 fd ff ff       	call   77304f30 <___wine_unimplemented>
7730517f:	90                   	nop    

77305180 <___wine_stub_iphlpapi_dll_73>:
77305180:	55                   	push   %ebp
77305181:	89 e5                	mov    %esp,%ebp
77305183:	50                   	push   %eax
77305184:	50                   	push   %eax
77305185:	b8 e3 a7 30 77       	mov    $0x7730a7e3,%eax
7730518a:	e8 a1 fd ff ff       	call   77304f30 <___wine_unimplemented>
7730518f:	90                   	nop    

77305190 <___wine_stub_iphlpapi_dll_74>:
77305190:	55                   	push   %ebp
77305191:	b8 f2 a7 30 77       	mov    $0x7730a7f2,%eax
77305196:	89 e5                	mov    %esp,%ebp
77305198:	52                   	push   %edx
77305199:	52                   	push   %edx
7730519a:	e8 91 fd ff ff       	call   77304f30 <___wine_unimplemented>
7730519f:	90                   	nop    

773051a0 <___wine_stub_iphlpapi_dll_75>:
773051a0:	55                   	push   %ebp
773051a1:	b8 06 a8 30 77       	mov    $0x7730a806,%eax
773051a6:	89 e5                	mov    %esp,%ebp
773051a8:	51                   	push   %ecx
773051a9:	51                   	push   %ecx
773051aa:	e8 81 fd ff ff       	call   77304f30 <___wine_unimplemented>
773051af:	90                   	nop    

773051b0 <___wine_stub_iphlpapi_dll_76>:
773051b0:	55                   	push   %ebp
773051b1:	89 e5                	mov    %esp,%ebp
773051b3:	50                   	push   %eax
773051b4:	50                   	push   %eax
773051b5:	b8 16 a8 30 77       	mov    $0x7730a816,%eax
773051ba:	e8 71 fd ff ff       	call   77304f30 <___wine_unimplemented>
773051bf:	90                   	nop    

773051c0 <___wine_stub_iphlpapi_dll_77>:
773051c0:	55                   	push   %ebp
773051c1:	89 e5                	mov    %esp,%ebp
773051c3:	50                   	push   %eax
773051c4:	50                   	push   %eax
773051c5:	b8 31 a8 30 77       	mov    $0x7730a831,%eax
773051ca:	e8 61 fd ff ff       	call   77304f30 <___wine_unimplemented>
773051cf:	90                   	nop    

773051d0 <___wine_stub_iphlpapi_dll_78>:
773051d0:	55                   	push   %ebp
773051d1:	89 e5                	mov    %esp,%ebp
773051d3:	50                   	push   %eax
773051d4:	50                   	push   %eax
773051d5:	b8 4c a8 30 77       	mov    $0x7730a84c,%eax
773051da:	e8 51 fd ff ff       	call   77304f30 <___wine_unimplemented>
773051df:	90                   	nop    

773051e0 <___wine_stub_iphlpapi_dll_79>:
773051e0:	55                   	push   %ebp
773051e1:	89 e5                	mov    %esp,%ebp
773051e3:	50                   	push   %eax
773051e4:	50                   	push   %eax
773051e5:	b8 74 a8 30 77       	mov    $0x7730a874,%eax
773051ea:	e8 41 fd ff ff       	call   77304f30 <___wine_unimplemented>
773051ef:	90                   	nop    

773051f0 <___wine_stub_iphlpapi_dll_82>:
773051f0:	55                   	push   %ebp
773051f1:	89 e5                	mov    %esp,%ebp
773051f3:	50                   	push   %eax
773051f4:	50                   	push   %eax
773051f5:	b8 92 a8 30 77       	mov    $0x7730a892,%eax
773051fa:	e8 31 fd ff ff       	call   77304f30 <___wine_unimplemented>
773051ff:	90                   	nop    

77305200 <___wine_stub_iphlpapi_dll_98>:
77305200:	55                   	push   %ebp
77305201:	89 e5                	mov    %esp,%ebp
77305203:	50                   	push   %eax
77305204:	50                   	push   %eax
77305205:	b8 a6 a8 30 77       	mov    $0x7730a8a6,%eax
7730520a:	e8 21 fd ff ff       	call   77304f30 <___wine_unimplemented>
7730520f:	90                   	nop    

77305210 <___wine_stub_iphlpapi_dll_100>:
77305210:	55                   	push   %ebp
77305211:	b8 c4 a8 30 77       	mov    $0x7730a8c4,%eax
77305216:	89 e5                	mov    %esp,%ebp
77305218:	52                   	push   %edx
77305219:	52                   	push   %edx
7730521a:	e8 11 fd ff ff       	call   77304f30 <___wine_unimplemented>
7730521f:	90                   	nop    

77305220 <___wine_stub_iphlpapi_dll_101>:
77305220:	55                   	push   %ebp
77305221:	b8 e4 a8 30 77       	mov    $0x7730a8e4,%eax
77305226:	89 e5                	mov    %esp,%ebp
77305228:	51                   	push   %ecx
77305229:	51                   	push   %ecx
7730522a:	e8 01 fd ff ff       	call   77304f30 <___wine_unimplemented>
7730522f:	90                   	nop    

77305230 <___wine_stub_iphlpapi_dll_102>:
77305230:	55                   	push   %ebp
77305231:	89 e5                	mov    %esp,%ebp
77305233:	50                   	push   %eax
77305234:	50                   	push   %eax
77305235:	b8 03 a9 30 77       	mov    $0x7730a903,%eax
7730523a:	e8 f1 fc ff ff       	call   77304f30 <___wine_unimplemented>
7730523f:	90                   	nop    

77305240 <___wine_stub_iphlpapi_dll_103>:
77305240:	55                   	push   %ebp
77305241:	89 e5                	mov    %esp,%ebp
77305243:	50                   	push   %eax
77305244:	50                   	push   %eax
77305245:	b8 1e a9 30 77       	mov    $0x7730a91e,%eax
7730524a:	e8 e1 fc ff ff       	call   77304f30 <___wine_unimplemented>
7730524f:	90                   	nop    

77305250 <___wine_stub_iphlpapi_dll_104>:
77305250:	55                   	push   %ebp
77305251:	89 e5                	mov    %esp,%ebp
77305253:	50                   	push   %eax
77305254:	50                   	push   %eax
77305255:	b8 34 a9 30 77       	mov    $0x7730a934,%eax
7730525a:	e8 d1 fc ff ff       	call   77304f30 <___wine_unimplemented>
7730525f:	90                   	nop    

77305260 <___wine_stub_iphlpapi_dll_105>:
77305260:	55                   	push   %ebp
77305261:	89 e5                	mov    %esp,%ebp
77305263:	50                   	push   %eax
77305264:	50                   	push   %eax
77305265:	b8 49 a9 30 77       	mov    $0x7730a949,%eax
7730526a:	e8 c1 fc ff ff       	call   77304f30 <___wine_unimplemented>
7730526f:	90                   	nop    

77305270 <___wine_stub_iphlpapi_dll_106>:
77305270:	55                   	push   %ebp
77305271:	89 e5                	mov    %esp,%ebp
77305273:	50                   	push   %eax
77305274:	50                   	push   %eax
77305275:	b8 58 a9 30 77       	mov    $0x7730a958,%eax
7730527a:	e8 b1 fc ff ff       	call   77304f30 <___wine_unimplemented>
7730527f:	90                   	nop    

77305280 <___wine_stub_iphlpapi_dll_107>:
77305280:	55                   	push   %ebp
77305281:	89 e5                	mov    %esp,%ebp
77305283:	50                   	push   %eax
77305284:	50                   	push   %eax
77305285:	b8 75 a9 30 77       	mov    $0x7730a975,%eax
7730528a:	e8 a1 fc ff ff       	call   77304f30 <___wine_unimplemented>
7730528f:	90                   	nop    

77305290 <___wine_stub_iphlpapi_dll_108>:
77305290:	55                   	push   %ebp
77305291:	b8 82 a9 30 77       	mov    $0x7730a982,%eax
77305296:	89 e5                	mov    %esp,%ebp
77305298:	52                   	push   %edx
77305299:	52                   	push   %edx
7730529a:	e8 91 fc ff ff       	call   77304f30 <___wine_unimplemented>
7730529f:	90                   	nop    

773052a0 <___wine_stub_iphlpapi_dll_109>:
773052a0:	55                   	push   %ebp
773052a1:	b8 95 a9 30 77       	mov    $0x7730a995,%eax
773052a6:	89 e5                	mov    %esp,%ebp
773052a8:	51                   	push   %ecx
773052a9:	51                   	push   %ecx
773052aa:	e8 81 fc ff ff       	call   77304f30 <___wine_unimplemented>
773052af:	90                   	nop    

773052b0 <___wine_stub_iphlpapi_dll_111>:
773052b0:	55                   	push   %ebp
773052b1:	89 e5                	mov    %esp,%ebp
773052b3:	50                   	push   %eax
773052b4:	50                   	push   %eax
773052b5:	b8 b0 a9 30 77       	mov    $0x7730a9b0,%eax
773052ba:	e8 71 fc ff ff       	call   77304f30 <___wine_unimplemented>
773052bf:	90                   	nop    

773052c0 <___wine_stub_iphlpapi_dll_113>:
773052c0:	55                   	push   %ebp
773052c1:	89 e5                	mov    %esp,%ebp
773052c3:	50                   	push   %eax
773052c4:	50                   	push   %eax
773052c5:	b8 d4 a9 30 77       	mov    $0x7730a9d4,%eax
773052ca:	e8 61 fc ff ff       	call   77304f30 <___wine_unimplemented>
773052cf:	90                   	nop    

773052d0 <___wine_stub_iphlpapi_dll_114>:
773052d0:	55                   	push   %ebp
773052d1:	89 e5                	mov    %esp,%ebp
773052d3:	50                   	push   %eax
773052d4:	50                   	push   %eax
773052d5:	b8 f9 a9 30 77       	mov    $0x7730a9f9,%eax
773052da:	e8 51 fc ff ff       	call   77304f30 <___wine_unimplemented>
773052df:	90                   	nop    

773052e0 <___wine_stub_iphlpapi_dll_115>:
773052e0:	55                   	push   %ebp
773052e1:	89 e5                	mov    %esp,%ebp
773052e3:	50                   	push   %eax
773052e4:	50                   	push   %eax
773052e5:	b8 0c aa 30 77       	mov    $0x7730aa0c,%eax
773052ea:	e8 41 fc ff ff       	call   77304f30 <___wine_unimplemented>
773052ef:	90                   	nop    

773052f0 <___wine_stub_iphlpapi_dll_116>:
773052f0:	55                   	push   %ebp
773052f1:	89 e5                	mov    %esp,%ebp
773052f3:	50                   	push   %eax
773052f4:	50                   	push   %eax
773052f5:	b8 1d aa 30 77       	mov    $0x7730aa1d,%eax
773052fa:	e8 31 fc ff ff       	call   77304f30 <___wine_unimplemented>
773052ff:	90                   	nop    

77305300 <___wine_stub_iphlpapi_dll_83>:
77305300:	55                   	push   %ebp
77305301:	89 e5                	mov    %esp,%ebp
77305303:	50                   	push   %eax
77305304:	50                   	push   %eax
77305305:	b8 32 aa 30 77       	mov    $0x7730aa32,%eax
7730530a:	e8 21 fc ff ff       	call   77304f30 <___wine_unimplemented>
7730530f:	90                   	nop    

77305310 <___wine_stub_iphlpapi_dll_84>:
77305310:	55                   	push   %ebp
77305311:	b8 46 aa 30 77       	mov    $0x7730aa46,%eax
77305316:	89 e5                	mov    %esp,%ebp
77305318:	52                   	push   %edx
77305319:	52                   	push   %edx
7730531a:	e8 11 fc ff ff       	call   77304f30 <___wine_unimplemented>
7730531f:	90                   	nop    

77305320 <___wine_stub_iphlpapi_dll_86>:
77305320:	55                   	push   %ebp
77305321:	b8 55 aa 30 77       	mov    $0x7730aa55,%eax
77305326:	89 e5                	mov    %esp,%ebp
77305328:	51                   	push   %ecx
77305329:	51                   	push   %ecx
7730532a:	e8 01 fc ff ff       	call   77304f30 <___wine_unimplemented>
7730532f:	90                   	nop    

77305330 <___wine_stub_iphlpapi_dll_88>:
77305330:	55                   	push   %ebp
77305331:	89 e5                	mov    %esp,%ebp
77305333:	50                   	push   %eax
77305334:	50                   	push   %eax
77305335:	b8 67 aa 30 77       	mov    $0x7730aa67,%eax
7730533a:	e8 f1 fb ff ff       	call   77304f30 <___wine_unimplemented>
7730533f:	90                   	nop    

77305340 <___wine_stub_iphlpapi_dll_89>:
77305340:	55                   	push   %ebp
77305341:	89 e5                	mov    %esp,%ebp
77305343:	50                   	push   %eax
77305344:	50                   	push   %eax
77305345:	b8 80 aa 30 77       	mov    $0x7730aa80,%eax
7730534a:	e8 e1 fb ff ff       	call   77304f30 <___wine_unimplemented>
7730534f:	90                   	nop    

77305350 <___wine_stub_iphlpapi_dll_91>:
77305350:	55                   	push   %ebp
77305351:	89 e5                	mov    %esp,%ebp
77305353:	50                   	push   %eax
77305354:	50                   	push   %eax
77305355:	b8 9f aa 30 77       	mov    $0x7730aa9f,%eax
7730535a:	e8 d1 fb ff ff       	call   77304f30 <___wine_unimplemented>
7730535f:	90                   	nop    

77305360 <___wine_stub_iphlpapi_dll_92>:
77305360:	55                   	push   %ebp
77305361:	89 e5                	mov    %esp,%ebp
77305363:	50                   	push   %eax
77305364:	50                   	push   %eax
77305365:	b8 b4 aa 30 77       	mov    $0x7730aab4,%eax
7730536a:	e8 c1 fb ff ff       	call   77304f30 <___wine_unimplemented>
7730536f:	90                   	nop    

77305370 <___wine_stub_iphlpapi_dll_93>:
77305370:	55                   	push   %ebp
77305371:	89 e5                	mov    %esp,%ebp
77305373:	50                   	push   %eax
77305374:	50                   	push   %eax
77305375:	b8 cb aa 30 77       	mov    $0x7730aacb,%eax
7730537a:	e8 b1 fb ff ff       	call   77304f30 <___wine_unimplemented>
7730537f:	90                   	nop    

77305380 <___wine_stub_iphlpapi_dll_94>:
77305380:	55                   	push   %ebp
77305381:	89 e5                	mov    %esp,%ebp
77305383:	50                   	push   %eax
77305384:	50                   	push   %eax
77305385:	b8 dd aa 30 77       	mov    $0x7730aadd,%eax
7730538a:	e8 a1 fb ff ff       	call   77304f30 <___wine_unimplemented>
7730538f:	90                   	nop    

77305390 <___wine_stub_iphlpapi_dll_95>:
77305390:	55                   	push   %ebp
77305391:	b8 f5 aa 30 77       	mov    $0x7730aaf5,%eax
77305396:	89 e5                	mov    %esp,%ebp
77305398:	52                   	push   %edx
77305399:	52                   	push   %edx
7730539a:	e8 91 fb ff ff       	call   77304f30 <___wine_unimplemented>
7730539f:	90                   	nop    

773053a0 <___wine_stub_iphlpapi_dll_97>:
773053a0:	55                   	push   %ebp
773053a1:	b8 05 ab 30 77       	mov    $0x7730ab05,%eax
773053a6:	89 e5                	mov    %esp,%ebp
773053a8:	51                   	push   %ecx
773053a9:	51                   	push   %ecx
773053aa:	e8 81 fb ff ff       	call   77304f30 <___wine_unimplemented>
773053af:	90                   	nop    

773053b0 <_RegOpenKeyExA@20>:
773053b0:	ff 25 a4 e1 30 77    	jmp    *0x7730e1a4
773053b6:	90                   	nop    
773053b7:	90                   	nop    
	...

773053c0 <_RegQueryValueExA@24>:
773053c0:	ff 25 b0 e1 30 77    	jmp    *0x7730e1b0
773053c6:	90                   	nop    
773053c7:	90                   	nop    
	...

773053d0 <_RegCloseKey@4>:
773053d0:	ff 25 9c e1 30 77    	jmp    *0x7730e19c
773053d6:	90                   	nop    
773053d7:	90                   	nop    
	...

773053e0 <_RegQueryInfoKeyW@48>:
773053e0:	ff 25 ac e1 30 77    	jmp    *0x7730e1ac
773053e6:	90                   	nop    
773053e7:	90                   	nop    
	...

773053f0 <_RegOpenKeyExW@20>:
773053f0:	ff 25 a8 e1 30 77    	jmp    *0x7730e1a8
773053f6:	90                   	nop    
773053f7:	90                   	nop    
	...

77305400 <_RegEnumKeyExW@32>:
77305400:	ff 25 a0 e1 30 77    	jmp    *0x7730e1a0
77305406:	90                   	nop    
77305407:	90                   	nop    
	...

77305410 <_RegQueryValueExW@24>:
77305410:	ff 25 b4 e1 30 77    	jmp    *0x7730e1b4
77305416:	90                   	nop    
77305417:	90                   	nop    
	...

77305420 <_DeviceIoControl@32>:
77305420:	ff 25 c0 e1 30 77    	jmp    *0x7730e1c0
77305426:	90                   	nop    
77305427:	90                   	nop    
	...

77305430 <_GetProcessHeap@0>:
77305430:	ff 25 cc e1 30 77    	jmp    *0x7730e1cc
77305436:	90                   	nop    
77305437:	90                   	nop    
	...

77305440 <_HeapAlloc@12>:
77305440:	ff 25 d0 e1 30 77    	jmp    *0x7730e1d0
77305446:	90                   	nop    
77305447:	90                   	nop    
	...

77305450 <_HeapFree@12>:
77305450:	ff 25 d4 e1 30 77    	jmp    *0x7730e1d4
77305456:	90                   	nop    
77305457:	90                   	nop    
	...

77305460 <_DisableThreadLibraryCalls@4>:
77305460:	ff 25 c4 e1 30 77    	jmp    *0x7730e1c4
77305466:	90                   	nop    
77305467:	90                   	nop    
	...

77305470 <_GetComputerNameExA@12>:
77305470:	ff 25 c8 e1 30 77    	jmp    *0x7730e1c8
77305476:	90                   	nop    
77305477:	90                   	nop    
	...

77305480 <_RtlCustomCPToUnicodeN@24>:
PUSHORT NlsOemLeadByteInfo = NULL; /* exported */




#define INIT_FUNCTION

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






/*
 * @unimplemented
 */
NTSTATUS STDCALL
RtlCustomCPToUnicodeN(IN PCPTABLEINFO CustomCP,
                      PWCHAR UnicodeString,
                      ULONG UnicodeSize,
                      PULONG ResultSize,
                      PCHAR CustomString,
                      ULONG CustomSize)
{
77305480:	55                   	push   %ebp
77305481:	89 e5                	mov    %esp,%ebp
77305483:	57                   	push   %edi
77305484:	56                   	push   %esi
77305485:	53                   	push   %ebx
77305486:	83 ec 0c             	sub    $0xc,%esp
   ULONG Size = 0;
   ULONG i;

   if (CustomCP->DBCSCodePage == 0)
77305489:	8b 55 08             	mov    0x8(%ebp),%edx
7730548c:	8b 5d 0c             	mov    0xc(%ebp),%ebx
7730548f:	8b 45 10             	mov    0x10(%ebp),%eax
77305492:	8b 7d 14             	mov    0x14(%ebp),%edi
77305495:	8b 4d 18             	mov    0x18(%ebp),%ecx
77305498:	8b 75 1c             	mov    0x1c(%ebp),%esi
7730549b:	66 83 7a 0c 00       	cmpw   $0x0,0xc(%edx)
773054a0:	75 40                	jne    773054e2 <_RtlCustomCPToUnicodeN@24+0x62>
   {
      /* single-byte code page */
      if (CustomSize > (UnicodeSize / sizeof(WCHAR)))
773054a2:	d1 e8                	shr    %eax
         Size = UnicodeSize / sizeof(WCHAR);
773054a4:	89 c2                	mov    %eax,%edx
773054a6:	39 f0                	cmp    %esi,%eax
773054a8:	73 34                	jae    773054de <_RtlCustomCPToUnicodeN@24+0x5e>
      else
         Size = CustomSize;

      if (ResultSize != NULL)
773054aa:	85 ff                	test   %edi,%edi
773054ac:	74 05                	je     773054b3 <_RtlCustomCPToUnicodeN@24+0x33>
         *ResultSize = Size * sizeof(WCHAR);
773054ae:	8d 04 12             	lea    (%edx,%edx,1),%eax
773054b1:	89 07                	mov    %eax,(%edi)

      for (i = 0; i < Size; i++)
773054b3:	85 d2                	test   %edx,%edx
773054b5:	74 1b                	je     773054d2 <_RtlCustomCPToUnicodeN@24+0x52>
773054b7:	8b 45 08             	mov    0x8(%ebp),%eax
773054ba:	8b 70 1c             	mov    0x1c(%eax),%esi
773054bd:	8d 76 00             	lea    0x0(%esi),%esi
      {
         *UnicodeString = CustomCP->MultiByteTable[(UCHAR)*CustomString];
773054c0:	31 c0                	xor    %eax,%eax
773054c2:	8a 01                	mov    (%ecx),%al
         UnicodeString++;
         CustomString++;
773054c4:	41                   	inc    %ecx
773054c5:	66 8b 04 46          	mov    (%esi,%eax,2),%ax
773054c9:	66 89 03             	mov    %ax,(%ebx)
773054cc:	83 c3 02             	add    $0x2,%ebx
773054cf:	4a                   	dec    %edx
773054d0:	75 ee                	jne    773054c0 <_RtlCustomCPToUnicodeN@24+0x40>
      }
   }
   else
   {
      /* multi-byte code page */
      /* FIXME */
      ASSERT(FALSE);
   }

   return(STATUS_SUCCESS);
}
773054d2:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773054d5:	31 c0                	xor    %eax,%eax
773054d7:	5b                   	pop    %ebx
773054d8:	5e                   	pop    %esi
773054d9:	5f                   	pop    %edi
773054da:	5d                   	pop    %ebp
773054db:	c2 18 00             	ret    $0x18
773054de:	89 f2                	mov    %esi,%edx
773054e0:	eb c8                	jmp    773054aa <_RtlCustomCPToUnicodeN@24+0x2a>
773054e2:	68 20 ab 30 77       	push   $0x7730ab20
773054e7:	6a 59                	push   $0x59
773054e9:	68 21 ab 30 77       	push   $0x7730ab21
773054ee:	68 27 ab 30 77       	push   $0x7730ab27
773054f3:	e8 d8 1d 00 00       	call   773072d0 <_RtlAssert@16>
773054f8:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773054fb:	31 c0                	xor    %eax,%eax
773054fd:	5b                   	pop    %ebx
773054fe:	5e                   	pop    %esi
773054ff:	5f                   	pop    %edi
77305500:	5d                   	pop    %ebp
77305501:	c2 18 00             	ret    $0x18
77305504:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
7730550a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

77305510 <_RtlDowncaseUnicodeChar@4>:



WCHAR STDCALL
RtlDowncaseUnicodeChar (IN WCHAR Source)
{
77305510:	55                   	push   %ebp
77305511:	89 e5                	mov    %esp,%ebp
77305513:	53                   	push   %ebx
77305514:	8b 5d 08             	mov    0x8(%ebp),%ebx
   USHORT Offset;

   if (Source < L'A')
77305517:	66 83 fb 40          	cmp    $0x40,%bx
7730551b:	76 13                	jbe    77305530 <_RtlDowncaseUnicodeChar@4+0x20>
      return Source;

   if (Source <= L'Z')
7730551d:	66 83 fb 5a          	cmp    $0x5a,%bx
      return Source + (L'a' - L'A');
77305521:	8d 43 20             	lea    0x20(%ebx),%eax
77305524:	76 0c                	jbe    77305532 <_RtlDowncaseUnicodeChar@4+0x22>

   if (Source < 0x80)
77305526:	66 83 fb 7f          	cmp    $0x7f,%bx
7730552a:	77 14                	ja     77305540 <_RtlDowncaseUnicodeChar@4+0x30>
7730552c:	8d 74 26 00          	lea    0x0(%esi),%esi
      return Source;

   Offset = ((USHORT)Source >> 8);
   DPRINT("Offset: %hx\n", Offset);

   Offset = NlsUnicodeLowercaseTable[Offset];
   DPRINT("Offset: %hx\n", Offset);

   Offset += (((USHORT)Source & 0x00F0) >> 4);
   DPRINT("Offset: %hx\n", Offset);

   Offset = NlsUnicodeLowercaseTable[Offset];
   DPRINT("Offset: %hx\n", Offset);

   Offset += ((USHORT)Source & 0x000F);
   DPRINT("Offset: %hx\n", Offset);

   Offset = NlsUnicodeLowercaseTable[Offset];
   DPRINT("Offset: %hx\n", Offset);

   DPRINT("Result: %hx\n", Source + (SHORT)Offset);

   return Source + (SHORT)Offset;
77305530:	89 d8                	mov    %ebx,%eax
77305532:	25 ff ff 00 00       	and    $0xffff,%eax
}
77305537:	5b                   	pop    %ebx
77305538:	5d                   	pop    %ebp
77305539:	c2 04 00             	ret    $0x4
7730553c:	8d 74 26 00          	lea    0x0(%esi),%esi
77305540:	89 d8                	mov    %ebx,%eax
77305542:	8b 0d 48 c0 30 77    	mov    0x7730c048,%ecx
77305548:	0f b6 d7             	movzbl %bh,%edx
7730554b:	25 f0 00 00 00       	and    $0xf0,%eax
77305550:	c1 f8 04             	sar    $0x4,%eax
77305553:	66 03 04 51          	add    (%ecx,%edx,2),%ax
77305557:	89 da                	mov    %ebx,%edx
77305559:	25 ff ff 00 00       	and    $0xffff,%eax
7730555e:	83 e2 0f             	and    $0xf,%edx
77305561:	66 03 14 41          	add    (%ecx,%eax,2),%dx
77305565:	81 e2 ff ff 00 00    	and    $0xffff,%edx
7730556b:	66 03 1c 51          	add    (%ecx,%edx,2),%bx
7730556f:	eb bf                	jmp    77305530 <_RtlDowncaseUnicodeChar@4+0x20>
77305571:	eb 0d                	jmp    77305580 <_RtlGetDefaultCodePage@8>
77305573:	90                   	nop    
77305574:	90                   	nop    
77305575:	90                   	nop    
77305576:	90                   	nop    
77305577:	90                   	nop    
77305578:	90                   	nop    
77305579:	90                   	nop    
7730557a:	90                   	nop    
7730557b:	90                   	nop    
7730557c:	90                   	nop    
7730557d:	90                   	nop    
7730557e:	90                   	nop    
7730557f:	90                   	nop    

77305580 <_RtlGetDefaultCodePage@8>:




/*
 * @implemented
 */
VOID STDCALL
RtlGetDefaultCodePage(OUT PUSHORT AnsiCodePage,
                      OUT PUSHORT OemCodePage)
{
77305580:	55                   	push   %ebp
   *AnsiCodePage = NlsAnsiCodePage;
77305581:	66 8b 15 46 c0 30 77 	mov    0x7730c046,%dx
77305588:	89 e5                	mov    %esp,%ebp
7730558a:	8b 45 08             	mov    0x8(%ebp),%eax
7730558d:	66 89 10             	mov    %dx,(%eax)
   *OemCodePage = NlsOemCodePage;
77305590:	8b 45 0c             	mov    0xc(%ebp),%eax
77305593:	66 8b 15 32 c0 30 77 	mov    0x7730c032,%dx
7730559a:	66 89 10             	mov    %dx,(%eax)
7730559d:	5d                   	pop    %ebp
7730559e:	c2 08 00             	ret    $0x8
773055a1:	eb 0d                	jmp    773055b0 <_RtlInitCodePageTable@8>
773055a3:	90                   	nop    
773055a4:	90                   	nop    
773055a5:	90                   	nop    
773055a6:	90                   	nop    
773055a7:	90                   	nop    
773055a8:	90                   	nop    
773055a9:	90                   	nop    
773055aa:	90                   	nop    
773055ab:	90                   	nop    
773055ac:	90                   	nop    
773055ad:	90                   	nop    
773055ae:	90                   	nop    
773055af:	90                   	nop    

773055b0 <_RtlInitCodePageTable@8>:
}




/*
 * @implemented
 */
VOID STDCALL
RtlInitCodePageTable(IN PUSHORT TableBase,
                     OUT PCPTABLEINFO CodePageTable)
{
773055b0:	55                   	push   %ebp
773055b1:	89 e5                	mov    %esp,%ebp
773055b3:	56                   	push   %esi
773055b4:	53                   	push   %ebx
773055b5:	8b 75 08             	mov    0x8(%ebp),%esi
773055b8:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   PNLS_FILE_HEADER NlsFileHeader;
   PUSHORT Ptr;
   USHORT Offset;

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

   NlsFileHeader = (PNLS_FILE_HEADER)TableBase;

   CodePageTable->CodePage = NlsFileHeader->CodePage;
773055bb:	66 8b 46 02          	mov    0x2(%esi),%ax
773055bf:	66 89 03             	mov    %ax,(%ebx)
   CodePageTable->MaximumCharacterSize = NlsFileHeader->MaximumCharacterSize;
773055c2:	66 8b 46 04          	mov    0x4(%esi),%ax
773055c6:	66 89 43 02          	mov    %ax,0x2(%ebx)
   CodePageTable->DefaultChar = NlsFileHeader->DefaultChar;
773055ca:	66 8b 46 06          	mov    0x6(%esi),%ax
773055ce:	66 89 43 04          	mov    %ax,0x4(%ebx)
   CodePageTable->UniDefaultChar = NlsFileHeader->UniDefaultChar;
773055d2:	66 8b 46 08          	mov    0x8(%esi),%ax
773055d6:	66 89 43 06          	mov    %ax,0x6(%ebx)
   CodePageTable->TransDefaultChar = NlsFileHeader->TransDefaultChar;
773055da:	66 8b 46 0a          	mov    0xa(%esi),%ax
773055de:	66 89 43 08          	mov    %ax,0x8(%ebx)
   CodePageTable->TransUniDefaultChar = NlsFileHeader->TransUniDefaultChar;
773055e2:	66 8b 46 0c          	mov    0xc(%esi),%ax
773055e6:	66 89 43 0a          	mov    %ax,0xa(%ebx)

   RtlCopyMemory(&CodePageTable->LeadByte,
773055ea:	50                   	push   %eax
773055eb:	8d 46 10             	lea    0x10(%esi),%eax
773055ee:	6a 0c                	push   $0xc
773055f0:	50                   	push   %eax
773055f1:	8d 43 0e             	lea    0xe(%ebx),%eax
773055f4:	50                   	push   %eax
773055f5:	e8 36 23 00 00       	call   77307930 <_memcpy>
                 &NlsFileHeader->LeadByte,
                 MAXIMUM_LEADBYTES);

   /* Set Pointer to start of multi byte table */
   Ptr = (PUSHORT)((ULONG_PTR)TableBase + 2 * NlsFileHeader->HeaderSize);
773055fa:	66 8b 06             	mov    (%esi),%ax

   /* Get offset to the wide char table */
   Offset = (USHORT)(*Ptr++) + NlsFileHeader->HeaderSize + 1;

   /* Set pointer to the multi byte table */
   CodePageTable->MultiByteTable = Ptr;

   /* Skip ANSI and OEM table */
   Ptr += 256;
   if (*Ptr++)
773055fd:	83 c4 10             	add    $0x10,%esp
77305600:	89 c2                	mov    %eax,%edx
77305602:	81 e2 ff ff 00 00    	and    $0xffff,%edx
77305608:	8d 14 56             	lea    (%esi,%edx,2),%edx
7730560b:	66 03 02             	add    (%edx),%ax
7730560e:	83 c2 02             	add    $0x2,%edx
77305611:	89 53 1c             	mov    %edx,0x1c(%ebx)
77305614:	81 c2 00 02 00 00    	add    $0x200,%edx
7730561a:	8d 48 01             	lea    0x1(%eax),%ecx
7730561d:	66 8b 02             	mov    (%edx),%ax
77305620:	83 c2 02             	add    $0x2,%edx
77305623:	66 85 c0             	test   %ax,%ax
77305626:	74 06                	je     7730562e <_RtlInitCodePageTable@8+0x7e>
      Ptr += 256;
77305628:	81 c2 00 02 00 00    	add    $0x200,%edx

   /* Set pointer to DBCS ranges */
   CodePageTable->DBCSRanges = (PUSHORT)Ptr;

   if (*Ptr > 0)
7730562e:	66 83 3a 00          	cmpw   $0x0,(%edx)
77305632:	89 53 24             	mov    %edx,0x24(%ebx)
77305635:	74 29                	je     77305660 <_RtlInitCodePageTable@8+0xb0>
   {
      CodePageTable->DBCSCodePage = 1;
      CodePageTable->DBCSOffsets = (PUSHORT)++Ptr;
   }
   else
   {
      CodePageTable->DBCSCodePage = 0;
      CodePageTable->DBCSOffsets = 0;
   }

   CodePageTable->WideCharTable = (PVOID)((ULONG_PTR)TableBase + 2 * Offset);
77305637:	89 c8                	mov    %ecx,%eax
77305639:	83 c2 02             	add    $0x2,%edx
7730563c:	25 ff ff 00 00       	and    $0xffff,%eax
77305641:	66 c7 43 0c 01 00    	movw   $0x1,0xc(%ebx)
77305647:	89 53 28             	mov    %edx,0x28(%ebx)
7730564a:	8d 04 46             	lea    (%esi,%eax,2),%eax
7730564d:	89 43 20             	mov    %eax,0x20(%ebx)
77305650:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
77305653:	5b                   	pop    %ebx
77305654:	5e                   	pop    %esi
77305655:	5d                   	pop    %ebp
77305656:	c2 08 00             	ret    $0x8
77305659:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
77305660:	89 c8                	mov    %ecx,%eax
77305662:	66 c7 43 0c 00 00    	movw   $0x0,0xc(%ebx)
77305668:	25 ff ff 00 00       	and    $0xffff,%eax
7730566d:	c7 43 28 00 00 00 00 	movl   $0x0,0x28(%ebx)
77305674:	8d 04 46             	lea    (%esi,%eax,2),%eax
77305677:	89 43 20             	mov    %eax,0x20(%ebx)
7730567a:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
7730567d:	5b                   	pop    %ebx
7730567e:	5e                   	pop    %esi
7730567f:	5d                   	pop    %ebp
77305680:	c2 08 00             	ret    $0x8
77305683:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77305689:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77305690 <_RtlInitNlsTables@16>:
}




/*
 * @implemented
 */
VOID STDCALL
RtlInitNlsTables(IN PUSHORT AnsiTableBase,
                 IN PUSHORT OemTableBase,
                 IN PUSHORT CaseTableBase,
                 OUT PNLSTABLEINFO NlsTable)
{
77305690:	55                   	push   %ebp
77305691:	89 e5                	mov    %esp,%ebp
77305693:	57                   	push   %edi
77305694:	56                   	push   %esi
77305695:	53                   	push   %ebx
77305696:	83 ec 0c             	sub    $0xc,%esp
77305699:	8b 4d 08             	mov    0x8(%ebp),%ecx
7730569c:	8b 7d 0c             	mov    0xc(%ebp),%edi
   DPRINT("RtlInitNlsTables()called\n");

   if (AnsiTableBase == NULL ||
7730569f:	85 c9                	test   %ecx,%ecx
773056a1:	8b 5d 10             	mov    0x10(%ebp),%ebx
773056a4:	0f 94 c2             	sete   %dl
773056a7:	85 ff                	test   %edi,%edi
773056a9:	8b 75 14             	mov    0x14(%ebp),%esi
773056ac:	0f 94 c0             	sete   %al
773056af:	09 d0                	or     %edx,%eax
773056b1:	a8 01                	test   $0x1,%al
773056b3:	75 2d                	jne    773056e2 <_RtlInitNlsTables@16+0x52>
773056b5:	85 db                	test   %ebx,%ebx
773056b7:	74 29                	je     773056e2 <_RtlInitNlsTables@16+0x52>
         OemTableBase == NULL ||
         CaseTableBase == NULL)
      return;

   RtlInitCodePageTable (AnsiTableBase,
773056b9:	8d 46 2c             	lea    0x2c(%esi),%eax
773056bc:	52                   	push   %edx
773056bd:	52                   	push   %edx
773056be:	50                   	push   %eax
773056bf:	51                   	push   %ecx
773056c0:	e8 eb fe ff ff       	call   773055b0 <_RtlInitCodePageTable@8>
                         &NlsTable->AnsiTableInfo);

   RtlInitCodePageTable (OemTableBase,
773056c5:	56                   	push   %esi
773056c6:	57                   	push   %edi
773056c7:	e8 e4 fe ff ff       	call   773055b0 <_RtlInitCodePageTable@8>
                         &NlsTable->OemTableInfo);

   NlsTable->UpperCaseTable = (PUSHORT)CaseTableBase + 2;
773056cc:	8d 43 04             	lea    0x4(%ebx),%eax
773056cf:	89 46 58             	mov    %eax,0x58(%esi)
   NlsTable->LowerCaseTable = (PUSHORT)CaseTableBase + *((PUSHORT)CaseTableBase + 1) + 2;
773056d2:	66 8b 43 02          	mov    0x2(%ebx),%ax
773056d6:	25 ff ff 00 00       	and    $0xffff,%eax
773056db:	8d 44 43 04          	lea    0x4(%ebx,%eax,2),%eax
773056df:	89 46 5c             	mov    %eax,0x5c(%esi)
}
773056e2:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773056e5:	5b                   	pop    %ebx
773056e6:	5e                   	pop    %esi
773056e7:	5f                   	pop    %edi
773056e8:	5d                   	pop    %ebp
773056e9:	c2 10 00             	ret    $0x10
773056ec:	8d 74 26 00          	lea    0x0(%esi),%esi

773056f0 <_RtlMultiByteToUnicodeN@20>:


/*
 * @unimplemented
 */
NTSTATUS STDCALL
RtlMultiByteToUnicodeN(
   IN PWCHAR UnicodeString,
   IN ULONG UnicodeSize,
   IN PULONG ResultSize,
   IN PCHAR MbString,
   IN ULONG MbSize)
{
773056f0:	55                   	push   %ebp
773056f1:	89 e5                	mov    %esp,%ebp
773056f3:	57                   	push   %edi
773056f4:	56                   	push   %esi
773056f5:	53                   	push   %ebx
773056f6:	83 ec 0c             	sub    $0xc,%esp
773056f9:	8b 7d 08             	mov    0x8(%ebp),%edi
773056fc:	8b 45 0c             	mov    0xc(%ebp),%eax
773056ff:	8b 5d 10             	mov    0x10(%ebp),%ebx
77305702:	8b 75 14             	mov    0x14(%ebp),%esi
77305705:	8b 55 18             	mov    0x18(%ebp),%edx
   ULONG Size = 0;
   ULONG i;

   if (NlsMbCodePageTag == FALSE)
77305708:	80 3d 44 c0 30 77 00 	cmpb   $0x0,0x7730c044
7730570f:	75 41                	jne    77305752 <_RtlMultiByteToUnicodeN@20+0x62>
   {
      /* single-byte code page */
      if (MbSize > (UnicodeSize / sizeof(WCHAR)))
77305711:	d1 e8                	shr    %eax
         Size = UnicodeSize / sizeof(WCHAR);
77305713:	89 c1                	mov    %eax,%ecx
77305715:	39 d0                	cmp    %edx,%eax
77305717:	73 35                	jae    7730574e <_RtlMultiByteToUnicodeN@20+0x5e>
      else
         Size = MbSize;

      if (ResultSize != NULL)
77305719:	85 db                	test   %ebx,%ebx
7730571b:	74 05                	je     77305722 <_RtlMultiByteToUnicodeN@20+0x32>
         *ResultSize = Size * sizeof(WCHAR);
7730571d:	8d 04 09             	lea    (%ecx,%ecx,1),%eax
77305720:	89 03                	mov    %eax,(%ebx)

      for (i = 0; i < Size; i++)
77305722:	31 d2                	xor    %edx,%edx
77305724:	39 ca                	cmp    %ecx,%edx
77305726:	73 1a                	jae    77305742 <_RtlMultiByteToUnicodeN@20+0x52>
77305728:	8b 1d 40 c0 30 77    	mov    0x7730c040,%ebx
7730572e:	89 f6                	mov    %esi,%esi
         UnicodeString[i] = NlsAnsiToUnicodeTable[(UCHAR)MbString[i]];
77305730:	31 c0                	xor    %eax,%eax
77305732:	8a 04 32             	mov    (%edx,%esi,1),%al
77305735:	66 8b 04 43          	mov    (%ebx,%eax,2),%ax
77305739:	66 89 04 57          	mov    %ax,(%edi,%edx,2)
7730573d:	42                   	inc    %edx
7730573e:	39 ca                	cmp    %ecx,%edx
77305740:	72 ee                	jb     77305730 <_RtlMultiByteToUnicodeN@20+0x40>
   }
   else
   {
      /* multi-byte code page */
      /* FIXME */
      ASSERT(FALSE);
   }

   return(STATUS_SUCCESS);
}
77305742:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77305745:	31 c0                	xor    %eax,%eax
77305747:	5b                   	pop    %ebx
77305748:	5e                   	pop    %esi
77305749:	5f                   	pop    %edi
7730574a:	5d                   	pop    %ebp
7730574b:	c2 14 00             	ret    $0x14
7730574e:	89 d1                	mov    %edx,%ecx
77305750:	eb c7                	jmp    77305719 <_RtlMultiByteToUnicodeN@20+0x29>
77305752:	68 20 ab 30 77       	push   $0x7730ab20
77305757:	68 0e 01 00 00       	push   $0x10e
7730575c:	68 21 ab 30 77       	push   $0x7730ab21
77305761:	68 27 ab 30 77       	push   $0x7730ab27
77305766:	e8 65 1b 00 00       	call   773072d0 <_RtlAssert@16>
7730576b:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
7730576e:	31 c0                	xor    %eax,%eax
77305770:	5b                   	pop    %ebx
77305771:	5e                   	pop    %esi
77305772:	5f                   	pop    %edi
77305773:	5d                   	pop    %ebp
77305774:	c2 14 00             	ret    $0x14
77305777:	89 f6                	mov    %esi,%esi
77305779:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77305780 <_RtlMultiByteToUnicodeSize@12>:



/*
 * @implemented
 */
NTSTATUS STDCALL
RtlMultiByteToUnicodeSize(PULONG UnicodeSize,
                          PCHAR MbString,
                          ULONG MbSize)
{
77305780:	55                   	push   %ebp
77305781:	89 e5                	mov    %esp,%ebp
77305783:	57                   	push   %edi
   ULONG Length;

   if (NlsMbCodePageTag == FALSE)
77305784:	80 3d 44 c0 30 77 00 	cmpb   $0x0,0x7730c044
7730578b:	8b 55 10             	mov    0x10(%ebp),%edx
7730578e:	56                   	push   %esi
7730578f:	8b 7d 08             	mov    0x8(%ebp),%edi
77305792:	53                   	push   %ebx
77305793:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   {
      /* single-byte code page */
      *UnicodeSize = MbSize * sizeof (WCHAR);
77305796:	8d 04 12             	lea    (%edx,%edx,1),%eax
77305799:	74 23                	je     773057be <_RtlMultiByteToUnicodeSize@12+0x3e>
   }
   else
   {
      /* multi-byte code page */
      for (Length = 0; MbSize; MbSize--, MbString++, Length++)
7730579b:	31 db                	xor    %ebx,%ebx
7730579d:	85 d2                	test   %edx,%edx
7730579f:	74 1a                	je     773057bb <_RtlMultiByteToUnicodeSize@12+0x3b>
773057a1:	8b 35 34 c0 30 77    	mov    0x7730c034,%esi
      {
         if (NlsLeadByteInfo[(UCHAR)*MbString] != 0)
773057a7:	31 c0                	xor    %eax,%eax
773057a9:	8a 01                	mov    (%ecx),%al
773057ab:	66 83 3c 46 00       	cmpw   $0x0,(%esi,%eax,2)
773057b0:	74 04                	je     773057b6 <_RtlMultiByteToUnicodeSize@12+0x36>
         {
            if (!--MbSize)
773057b2:	4a                   	dec    %edx
773057b3:	74 06                	je     773057bb <_RtlMultiByteToUnicodeSize@12+0x3b>
               break;  /* partial char, ignore it */
            MbString++;
773057b5:	41                   	inc    %ecx
773057b6:	41                   	inc    %ecx
773057b7:	43                   	inc    %ebx
773057b8:	4a                   	dec    %edx
773057b9:	75 ec                	jne    773057a7 <_RtlMultiByteToUnicodeSize@12+0x27>
         }
      }

      *UnicodeSize = Length * sizeof(WCHAR);
773057bb:	8d 04 1b             	lea    (%ebx,%ebx,1),%eax
773057be:	89 07                	mov    %eax,(%edi)
   }

   return STATUS_SUCCESS;
}
773057c0:	31 c0                	xor    %eax,%eax
773057c2:	5b                   	pop    %ebx
773057c3:	5e                   	pop    %esi
773057c4:	5f                   	pop    %edi
773057c5:	5d                   	pop    %ebp
773057c6:	c2 0c 00             	ret    $0xc
773057c9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

773057d0 <_RtlOemToUnicodeN@20>:



/*
 * @unimplemented
 */
NTSTATUS STDCALL
RtlOemToUnicodeN (PWCHAR UnicodeString,
                  ULONG UnicodeSize,
                  PULONG ResultSize,
                  PCHAR OemString,
                  ULONG OemSize)
{
773057d0:	55                   	push   %ebp
773057d1:	89 e5                	mov    %esp,%ebp
773057d3:	57                   	push   %edi
773057d4:	56                   	push   %esi
773057d5:	53                   	push   %ebx
773057d6:	83 ec 0c             	sub    $0xc,%esp
773057d9:	8b 5d 08             	mov    0x8(%ebp),%ebx
773057dc:	8b 45 0c             	mov    0xc(%ebp),%eax
773057df:	8b 7d 10             	mov    0x10(%ebp),%edi
773057e2:	8b 4d 14             	mov    0x14(%ebp),%ecx
773057e5:	8b 75 18             	mov    0x18(%ebp),%esi
   ULONG Size = 0;
   ULONG i;

   if (NlsMbOemCodePageTag == FALSE)
773057e8:	80 3d 30 c0 30 77 00 	cmpb   $0x0,0x7730c030
773057ef:	75 40                	jne    77305831 <_RtlOemToUnicodeN@20+0x61>
   {
      /* single-byte code page */
      if (OemSize > (UnicodeSize / sizeof(WCHAR)))
773057f1:	d1 e8                	shr    %eax
         Size = UnicodeSize / sizeof(WCHAR);
773057f3:	89 c2                	mov    %eax,%edx
773057f5:	39 f0                	cmp    %esi,%eax
773057f7:	73 34                	jae    7730582d <_RtlOemToUnicodeN@20+0x5d>
      else
         Size = OemSize;

      if (ResultSize != NULL)
773057f9:	85 ff                	test   %edi,%edi
773057fb:	74 05                	je     77305802 <_RtlOemToUnicodeN@20+0x32>
         *ResultSize = Size * sizeof(WCHAR);
773057fd:	8d 04 12             	lea    (%edx,%edx,1),%eax
77305800:	89 07                	mov    %eax,(%edi)

      for (i = 0; i < Size; i++)
77305802:	85 d2                	test   %edx,%edx
77305804:	74 1b                	je     77305821 <_RtlOemToUnicodeN@20+0x51>
77305806:	8b 35 2c c0 30 77    	mov    0x7730c02c,%esi
7730580c:	8d 74 26 00          	lea    0x0(%esi),%esi
      {
         *UnicodeString = NlsOemToUnicodeTable[(INT)*OemString];
77305810:	0f be 01             	movsbl (%ecx),%eax
         UnicodeString++;
         OemString++;
77305813:	41                   	inc    %ecx
77305814:	66 8b 04 46          	mov    (%esi,%eax,2),%ax
77305818:	66 89 03             	mov    %ax,(%ebx)
7730581b:	83 c3 02             	add    $0x2,%ebx
7730581e:	4a                   	dec    %edx
7730581f:	75 ef                	jne    77305810 <_RtlOemToUnicodeN@20+0x40>
      }
   }
   else
   {
      /* multi-byte code page */
      /* FIXME */
      ASSERT(FALSE);
   }

   return STATUS_SUCCESS;
}
77305821:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77305824:	31 c0                	xor    %eax,%eax
77305826:	5b                   	pop    %ebx
77305827:	5e                   	pop    %esi
77305828:	5f                   	pop    %edi
77305829:	5d                   	pop    %ebp
7730582a:	c2 14 00             	ret    $0x14
7730582d:	89 f2                	mov    %esi,%edx
7730582f:	eb c8                	jmp    773057f9 <_RtlOemToUnicodeN@20+0x29>
77305831:	68 20 ab 30 77       	push   $0x7730ab20
77305836:	68 5d 01 00 00       	push   $0x15d
7730583b:	68 21 ab 30 77       	push   $0x7730ab21
77305840:	68 27 ab 30 77       	push   $0x7730ab27
77305845:	e8 86 1a 00 00       	call   773072d0 <_RtlAssert@16>
7730584a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
7730584d:	31 c0                	xor    %eax,%eax
7730584f:	5b                   	pop    %ebx
77305850:	5e                   	pop    %esi
77305851:	5f                   	pop    %edi
77305852:	5d                   	pop    %ebp
77305853:	c2 14 00             	ret    $0x14
77305856:	8d 76 00             	lea    0x0(%esi),%esi
77305859:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77305860 <_RtlResetRtlTranslations@4>:



/*
 * @implemented
 */
VOID STDCALL
RtlResetRtlTranslations(IN PNLSTABLEINFO NlsTable)
{
77305860:	55                   	push   %ebp
77305861:	89 e5                	mov    %esp,%ebp
77305863:	8b 55 08             	mov    0x8(%ebp),%edx
   DPRINT("RtlResetRtlTranslations() called\n");

   /* Set ANSI data */
   NlsAnsiToUnicodeTable = NlsTable->AnsiTableInfo.MultiByteTable;
   NlsUnicodeToAnsiTable = NlsTable->AnsiTableInfo.WideCharTable;
   NlsDbcsUnicodeToAnsiTable = (PWCHAR)NlsTable->AnsiTableInfo.WideCharTable;
   NlsMbCodePageTag = (NlsTable->AnsiTableInfo.DBCSCodePage != 0);
   NlsLeadByteInfo = NlsTable->AnsiTableInfo.DBCSOffsets;
   NlsAnsiCodePage = NlsTable->AnsiTableInfo.CodePage;
   DPRINT("Ansi codepage %hu\n", NlsAnsiCodePage);

   /* Set OEM data */
   NlsOemToUnicodeTable = NlsTable->OemTableInfo.MultiByteTable;
   NlsUnicodeToOemTable = NlsTable->OemTableInfo.WideCharTable;
   NlsDbcsUnicodeToOemTable = (PWCHAR)NlsTable->OemTableInfo.WideCharTable;
   NlsMbOemCodePageTag = (NlsTable->OemTableInfo.DBCSCodePage != 0);
   NlsOemLeadByteInfo = NlsTable->OemTableInfo.DBCSOffsets;
   NlsOemCodePage = NlsTable->OemTableInfo.CodePage;
   DPRINT("Oem codepage %hu\n", NlsOemCodePage);

   /* Set Unicode case map data */
   NlsUnicodeUpcaseTable = NlsTable->UpperCaseTable;
   NlsUnicodeLowercaseTable = NlsTable->LowerCaseTable;
77305866:	5d                   	pop    %ebp
77305867:	8b 42 48             	mov    0x48(%edx),%eax
7730586a:	a3 40 c0 30 77       	mov    %eax,0x7730c040
7730586f:	8b 42 4c             	mov    0x4c(%edx),%eax
77305872:	66 83 7a 38 00       	cmpw   $0x0,0x38(%edx)
77305877:	0f 95 05 44 c0 30 77 	setne  0x7730c044
7730587e:	a3 3c c0 30 77       	mov    %eax,0x7730c03c
77305883:	a3 38 c0 30 77       	mov    %eax,0x7730c038
77305888:	8b 42 54             	mov    0x54(%edx),%eax
7730588b:	a3 34 c0 30 77       	mov    %eax,0x7730c034
77305890:	66 8b 42 2c          	mov    0x2c(%edx),%ax
77305894:	66 a3 46 c0 30 77    	mov    %ax,0x7730c046
7730589a:	8b 42 1c             	mov    0x1c(%edx),%eax
7730589d:	a3 2c c0 30 77       	mov    %eax,0x7730c02c
773058a2:	8b 42 20             	mov    0x20(%edx),%eax
773058a5:	66 83 7a 0c 00       	cmpw   $0x0,0xc(%edx)
773058aa:	0f 95 05 30 c0 30 77 	setne  0x7730c030
773058b1:	a3 28 c0 30 77       	mov    %eax,0x7730c028
773058b6:	a3 24 c0 30 77       	mov    %eax,0x7730c024
773058bb:	8b 42 28             	mov    0x28(%edx),%eax
773058be:	a3 20 c0 30 77       	mov    %eax,0x7730c020
773058c3:	66 8b 02             	mov    (%edx),%ax
773058c6:	66 a3 32 c0 30 77    	mov    %ax,0x7730c032
773058cc:	8b 42 58             	mov    0x58(%edx),%eax
773058cf:	a3 4c c0 30 77       	mov    %eax,0x7730c04c
773058d4:	8b 42 5c             	mov    0x5c(%edx),%eax
773058d7:	a3 48 c0 30 77       	mov    %eax,0x7730c048
773058dc:	c2 04 00             	ret    $0x4
773058df:	90                   	nop    

773058e0 <_RtlUnicodeToCustomCPN@24>:
}



/*
 * @unimplemented
 */
NTSTATUS STDCALL
RtlUnicodeToCustomCPN(IN PCPTABLEINFO CustomCP,
                      PCHAR CustomString,
                      ULONG CustomSize,
                      PULONG ResultSize,
                      PWCHAR UnicodeString,
                      ULONG UnicodeSize)
{
773058e0:	55                   	push   %ebp
773058e1:	89 e5                	mov    %esp,%ebp
773058e3:	57                   	push   %edi
773058e4:	56                   	push   %esi
773058e5:	53                   	push   %ebx
773058e6:	83 ec 0c             	sub    $0xc,%esp
773058e9:	8b 7d 08             	mov    0x8(%ebp),%edi
773058ec:	8b 75 0c             	mov    0xc(%ebp),%esi
773058ef:	8b 55 10             	mov    0x10(%ebp),%edx
773058f2:	8b 5d 18             	mov    0x18(%ebp),%ebx
773058f5:	8b 4d 1c             	mov    0x1c(%ebp),%ecx
   ULONG Size = 0;
   ULONG i;

   if (CustomCP->DBCSCodePage == 0)
773058f8:	66 83 7f 0c 00       	cmpw   $0x0,0xc(%edi)
773058fd:	75 42                	jne    77305941 <_RtlUnicodeToCustomCPN@24+0x61>
   {
      /* single-byte code page */
      if (UnicodeSize > (CustomSize * sizeof(WCHAR)))
773058ff:	8d 04 12             	lea    (%edx,%edx,1),%eax
77305902:	39 c8                	cmp    %ecx,%eax
77305904:	73 35                	jae    7730593b <_RtlUnicodeToCustomCPN@24+0x5b>
         Size = CustomSize;
      else
         Size = UnicodeSize / sizeof(WCHAR);

      if (ResultSize != NULL)
77305906:	8b 4d 14             	mov    0x14(%ebp),%ecx
77305909:	85 c9                	test   %ecx,%ecx
7730590b:	74 05                	je     77305912 <_RtlUnicodeToCustomCPN@24+0x32>
         *ResultSize = Size;
7730590d:	8b 45 14             	mov    0x14(%ebp),%eax
77305910:	89 10                	mov    %edx,(%eax)

      for (i = 0; i < Size; i++)
77305912:	85 d2                	test   %edx,%edx
77305914:	74 19                	je     7730592f <_RtlUnicodeToCustomCPN@24+0x4f>
77305916:	89 d1                	mov    %edx,%ecx
      {
         *CustomString = ((PCHAR)CustomCP->WideCharTable)[*UnicodeString];
77305918:	66 8b 03             	mov    (%ebx),%ax
7730591b:	8b 57 20             	mov    0x20(%edi),%edx
7730591e:	25 ff ff 00 00       	and    $0xffff,%eax
         CustomString++;
         UnicodeString++;
77305923:	83 c3 02             	add    $0x2,%ebx
77305926:	8a 04 10             	mov    (%eax,%edx,1),%al
77305929:	88 06                	mov    %al,(%esi)
7730592b:	46                   	inc    %esi
7730592c:	49                   	dec    %ecx
7730592d:	75 e9                	jne    77305918 <_RtlUnicodeToCustomCPN@24+0x38>
      }
   }
   else
   {
      /* multi-byte code page */
      /* FIXME */
      ASSERT(FALSE);
   }

   return STATUS_SUCCESS;
}
7730592f:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77305932:	31 c0                	xor    %eax,%eax
77305934:	5b                   	pop    %ebx
77305935:	5e                   	pop    %esi
77305936:	5f                   	pop    %edi
77305937:	5d                   	pop    %ebp
77305938:	c2 18 00             	ret    $0x18
7730593b:	89 ca                	mov    %ecx,%edx
7730593d:	d1 ea                	shr    %edx
7730593f:	eb c5                	jmp    77305906 <_RtlUnicodeToCustomCPN@24+0x26>
77305941:	68 20 ab 30 77       	push   $0x7730ab20
77305946:	68 aa 01 00 00       	push   $0x1aa
7730594b:	68 21 ab 30 77       	push   $0x7730ab21
77305950:	68 27 ab 30 77       	push   $0x7730ab27
77305955:	e8 76 19 00 00       	call   773072d0 <_RtlAssert@16>
7730595a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
7730595d:	31 c0                	xor    %eax,%eax
7730595f:	5b                   	pop    %ebx
77305960:	5e                   	pop    %esi
77305961:	5f                   	pop    %edi
77305962:	5d                   	pop    %ebp
77305963:	c2 18 00             	ret    $0x18
77305966:	8d 76 00             	lea    0x0(%esi),%esi
77305969:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77305970 <_RtlUnicodeToMultiByteN@20>:



/*
 * @unimplemented
 */
NTSTATUS STDCALL
RtlUnicodeToMultiByteN (PCHAR MbString,
                        ULONG MbSize,
                        PULONG ResultSize,
                        PWCHAR UnicodeString,
                        ULONG UnicodeSize)
{
77305970:	55                   	push   %ebp
77305971:	89 e5                	mov    %esp,%ebp
77305973:	57                   	push   %edi
77305974:	56                   	push   %esi
77305975:	53                   	push   %ebx
77305976:	83 ec 0c             	sub    $0xc,%esp
77305979:	8b 75 08             	mov    0x8(%ebp),%esi
7730597c:	8b 55 0c             	mov    0xc(%ebp),%edx
7730597f:	8b 7d 10             	mov    0x10(%ebp),%edi
77305982:	8b 5d 14             	mov    0x14(%ebp),%ebx
77305985:	8b 4d 18             	mov    0x18(%ebp),%ecx
   ULONG Size = 0;
   ULONG i;

   if (NlsMbCodePageTag == FALSE)
77305988:	80 3d 44 c0 30 77 00 	cmpb   $0x0,0x7730c044
7730598f:	75 3f                	jne    773059d0 <_RtlUnicodeToMultiByteN@20+0x60>
   {
      /* single-byte code page */
      if (UnicodeSize > (MbSize * sizeof(WCHAR)))
77305991:	8d 04 12             	lea    (%edx,%edx,1),%eax
77305994:	39 c8                	cmp    %ecx,%eax
77305996:	73 32                	jae    773059ca <_RtlUnicodeToMultiByteN@20+0x5a>
         Size = MbSize;
      else
         Size = UnicodeSize / sizeof(WCHAR);

      if (ResultSize != NULL)
77305998:	85 ff                	test   %edi,%edi
7730599a:	74 02                	je     7730599e <_RtlUnicodeToMultiByteN@20+0x2e>
         *ResultSize = Size;
7730599c:	89 17                	mov    %edx,(%edi)

      for (i = 0; i < Size; i++)
7730599e:	85 d2                	test   %edx,%edx
773059a0:	74 1c                	je     773059be <_RtlUnicodeToMultiByteN@20+0x4e>
773059a2:	89 d1                	mov    %edx,%ecx
      {
         *MbString = NlsUnicodeToAnsiTable[*UnicodeString];
773059a4:	66 8b 03             	mov    (%ebx),%ax
773059a7:	8b 15 3c c0 30 77    	mov    0x7730c03c,%edx
773059ad:	25 ff ff 00 00       	and    $0xffff,%eax
         MbString++;
         UnicodeString++;
773059b2:	83 c3 02             	add    $0x2,%ebx
773059b5:	8a 04 02             	mov    (%edx,%eax,1),%al
773059b8:	88 06                	mov    %al,(%esi)
773059ba:	46                   	inc    %esi
773059bb:	49                   	dec    %ecx
773059bc:	75 e6                	jne    773059a4 <_RtlUnicodeToMultiByteN@20+0x34>
      }
   }
   else
   {
      /* multi-byte code page */
      /* FIXME */
      ASSERT(FALSE);
   }

   return STATUS_SUCCESS;
}
773059be:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773059c1:	31 c0                	xor    %eax,%eax
773059c3:	5b                   	pop    %ebx
773059c4:	5e                   	pop    %esi
773059c5:	5f                   	pop    %edi
773059c6:	5d                   	pop    %ebp
773059c7:	c2 14 00             	ret    $0x14
773059ca:	89 ca                	mov    %ecx,%edx
773059cc:	d1 ea                	shr    %edx
773059ce:	eb c8                	jmp    77305998 <_RtlUnicodeToMultiByteN@20+0x28>
773059d0:	68 20 ab 30 77       	push   $0x7730ab20
773059d5:	68 d5 01 00 00       	push   $0x1d5
773059da:	68 21 ab 30 77       	push   $0x7730ab21
773059df:	68 27 ab 30 77       	push   $0x7730ab27
773059e4:	e8 e7 18 00 00       	call   773072d0 <_RtlAssert@16>
773059e9:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773059ec:	31 c0                	xor    %eax,%eax
773059ee:	5b                   	pop    %ebx
773059ef:	5e                   	pop    %esi
773059f0:	5f                   	pop    %edi
773059f1:	5d                   	pop    %ebp
773059f2:	c2 14 00             	ret    $0x14
773059f5:	8d 74 26 00          	lea    0x0(%esi),%esi
773059f9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77305a00 <_RtlUnicodeToMultiByteSize@12>:


/*
 * @implemented
 */
NTSTATUS STDCALL
RtlUnicodeToMultiByteSize(PULONG MbSize,
                          PWCHAR UnicodeString,
                          ULONG UnicodeSize)
{
77305a00:	55                   	push   %ebp
77305a01:	89 e5                	mov    %esp,%ebp
77305a03:	57                   	push   %edi
77305a04:	56                   	push   %esi
77305a05:	53                   	push   %ebx
77305a06:	8b 7d 08             	mov    0x8(%ebp),%edi
77305a09:	8b 4d 0c             	mov    0xc(%ebp),%ecx
77305a0c:	8b 45 10             	mov    0x10(%ebp),%eax
   ULONG UnicodeLength;
   ULONG MbLength;

   if (NlsMbCodePageTag == FALSE)
77305a0f:	80 3d 44 c0 30 77 00 	cmpb   $0x0,0x7730c044
77305a16:	75 0d                	jne    77305a25 <_RtlUnicodeToMultiByteSize@12+0x25>
   {
      /* single-byte code page */
      *MbSize = UnicodeSize / sizeof (WCHAR);
77305a18:	d1 e8                	shr    %eax
77305a1a:	89 07                	mov    %eax,(%edi)
   }
   else
   {
      /* multi-byte code page */
      UnicodeLength = UnicodeSize / sizeof(WCHAR);
      MbLength = 0;
      while (UnicodeLength > 0)
      {
         if (NlsLeadByteInfo[(USHORT)*UnicodeString] & 0xff00)
            MbLength++;

         MbLength++;
         UnicodeLength--;
         UnicodeString++;
      }

      *MbSize = MbLength;
   }

   return(STATUS_SUCCESS);
}
77305a1c:	31 c0                	xor    %eax,%eax
77305a1e:	5b                   	pop    %ebx
77305a1f:	5e                   	pop    %esi
77305a20:	5f                   	pop    %edi
77305a21:	5d                   	pop    %ebp
77305a22:	c2 0c 00             	ret    $0xc
77305a25:	89 c2                	mov    %eax,%edx
77305a27:	31 db                	xor    %ebx,%ebx
77305a29:	d1 ea                	shr    %edx
77305a2b:	74 22                	je     77305a4f <_RtlUnicodeToMultiByteSize@12+0x4f>
77305a2d:	8b 35 34 c0 30 77    	mov    0x7730c034,%esi
77305a33:	66 8b 01             	mov    (%ecx),%ax
77305a36:	25 ff ff 00 00       	and    $0xffff,%eax
77305a3b:	66 8b 04 46          	mov    (%esi,%eax,2),%ax
77305a3f:	30 c0                	xor    %al,%al
77305a41:	66 83 f8 01          	cmp    $0x1,%ax
77305a45:	83 db ff             	sbb    $0xffffffff,%ebx
77305a48:	83 c1 02             	add    $0x2,%ecx
77305a4b:	43                   	inc    %ebx
77305a4c:	4a                   	dec    %edx
77305a4d:	75 e4                	jne    77305a33 <_RtlUnicodeToMultiByteSize@12+0x33>
77305a4f:	89 1f                	mov    %ebx,(%edi)
77305a51:	31 c0                	xor    %eax,%eax
77305a53:	5b                   	pop    %ebx
77305a54:	5e                   	pop    %esi
77305a55:	5f                   	pop    %edi
77305a56:	5d                   	pop    %ebp
77305a57:	c2 0c 00             	ret    $0xc
77305a5a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

77305a60 <_RtlUnicodeToOemN@20>:




/*
 * @unimplemented
 */
NTSTATUS STDCALL
RtlUnicodeToOemN (PCHAR OemString,
                  ULONG OemSize,
                  PULONG ResultSize,
                  PWCHAR UnicodeString,
                  ULONG UnicodeSize)
{
77305a60:	55                   	push   %ebp
77305a61:	89 e5                	mov    %esp,%ebp
77305a63:	57                   	push   %edi
77305a64:	56                   	push   %esi
77305a65:	53                   	push   %ebx
77305a66:	83 ec 0c             	sub    $0xc,%esp
77305a69:	8b 75 08             	mov    0x8(%ebp),%esi
77305a6c:	8b 55 0c             	mov    0xc(%ebp),%edx
77305a6f:	8b 7d 10             	mov    0x10(%ebp),%edi
77305a72:	8b 5d 14             	mov    0x14(%ebp),%ebx
77305a75:	8b 4d 18             	mov    0x18(%ebp),%ecx
   ULONG Size = 0;
   ULONG i;

   if (NlsMbOemCodePageTag == FALSE)
77305a78:	80 3d 30 c0 30 77 00 	cmpb   $0x0,0x7730c030
77305a7f:	75 3f                	jne    77305ac0 <_RtlUnicodeToOemN@20+0x60>
   {
      /* single-byte code page */
      if (UnicodeSize > (OemSize * sizeof(WCHAR)))
77305a81:	8d 04 12             	lea    (%edx,%edx,1),%eax
77305a84:	39 c8                	cmp    %ecx,%eax
77305a86:	73 32                	jae    77305aba <_RtlUnicodeToOemN@20+0x5a>
         Size = OemSize;
      else
         Size = UnicodeSize / sizeof(WCHAR);

      if (ResultSize != NULL)
77305a88:	85 ff                	test   %edi,%edi
77305a8a:	74 02                	je     77305a8e <_RtlUnicodeToOemN@20+0x2e>
         *ResultSize = Size;
77305a8c:	89 17                	mov    %edx,(%edi)

      for (i = 0; i < Size; i++)
77305a8e:	85 d2                	test   %edx,%edx
77305a90:	74 1c                	je     77305aae <_RtlUnicodeToOemN@20+0x4e>
77305a92:	89 d1                	mov    %edx,%ecx
      {
         *OemString = NlsUnicodeToOemTable[*UnicodeString];
77305a94:	66 8b 03             	mov    (%ebx),%ax
77305a97:	8b 15 28 c0 30 77    	mov    0x7730c028,%edx
77305a9d:	25 ff ff 00 00       	and    $0xffff,%eax
         OemString++;
         UnicodeString++;
77305aa2:	83 c3 02             	add    $0x2,%ebx
77305aa5:	8a 04 02             	mov    (%edx,%eax,1),%al
77305aa8:	88 06                	mov    %al,(%esi)
77305aaa:	46                   	inc    %esi
77305aab:	49                   	dec    %ecx
77305aac:	75 e6                	jne    77305a94 <_RtlUnicodeToOemN@20+0x34>
      }
   }
   else
   {
      /* multi-byte code page */
      /* FIXME */
      ASSERT(FALSE);
   }

   return STATUS_SUCCESS;
}
77305aae:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77305ab1:	31 c0                	xor    %eax,%eax
77305ab3:	5b                   	pop    %ebx
77305ab4:	5e                   	pop    %esi
77305ab5:	5f                   	pop    %edi
77305ab6:	5d                   	pop    %ebp
77305ab7:	c2 14 00             	ret    $0x14
77305aba:	89 ca                	mov    %ecx,%edx
77305abc:	d1 ea                	shr    %edx
77305abe:	eb c8                	jmp    77305a88 <_RtlUnicodeToOemN@20+0x28>
77305ac0:	68 20 ab 30 77       	push   $0x7730ab20
77305ac5:	68 27 02 00 00       	push   $0x227
77305aca:	68 21 ab 30 77       	push   $0x7730ab21
77305acf:	68 27 ab 30 77       	push   $0x7730ab27
77305ad4:	e8 f7 17 00 00       	call   773072d0 <_RtlAssert@16>
77305ad9:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77305adc:	31 c0                	xor    %eax,%eax
77305ade:	5b                   	pop    %ebx
77305adf:	5e                   	pop    %esi
77305ae0:	5f                   	pop    %edi
77305ae1:	5d                   	pop    %ebp
77305ae2:	c2 14 00             	ret    $0x14
77305ae5:	8d 74 26 00          	lea    0x0(%esi),%esi
77305ae9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77305af0 <_RtlUpcaseUnicodeChar@4>:




/*
 * @implemented
 */
WCHAR STDCALL
RtlUpcaseUnicodeChar(IN WCHAR Source)
{
77305af0:	55                   	push   %ebp
77305af1:	89 e5                	mov    %esp,%ebp
77305af3:	53                   	push   %ebx
77305af4:	8b 5d 08             	mov    0x8(%ebp),%ebx
   USHORT Offset;

   if (Source < L'a')
77305af7:	66 83 fb 60          	cmp    $0x60,%bx
77305afb:	76 38                	jbe    77305b35 <_RtlUpcaseUnicodeChar@4+0x45>
      return Source;

   if (Source <= L'z')
77305afd:	66 83 fb 7a          	cmp    $0x7a,%bx
      return (Source - (L'a' - L'A'));
77305b01:	8d 43 e0             	lea    0xffffffe0(%ebx),%eax
77305b04:	76 31                	jbe    77305b37 <_RtlUpcaseUnicodeChar@4+0x47>

   Offset = ((USHORT)Source >> 8);
   Offset = NlsUnicodeUpcaseTable[Offset];

   Offset += (((USHORT)Source & 0x00F0) >> 4);
77305b06:	89 d8                	mov    %ebx,%eax
77305b08:	8b 0d 4c c0 30 77    	mov    0x7730c04c,%ecx
77305b0e:	0f b6 d7             	movzbl %bh,%edx
77305b11:	25 f0 00 00 00       	and    $0xf0,%eax
77305b16:	c1 f8 04             	sar    $0x4,%eax
77305b19:	66 03 04 51          	add    (%ecx,%edx,2),%ax
   Offset = NlsUnicodeUpcaseTable[Offset];

   Offset += ((USHORT)Source & 0x000F);
77305b1d:	89 da                	mov    %ebx,%edx
77305b1f:	25 ff ff 00 00       	and    $0xffff,%eax
77305b24:	83 e2 0f             	and    $0xf,%edx
77305b27:	66 03 14 41          	add    (%ecx,%eax,2),%dx
   Offset = NlsUnicodeUpcaseTable[Offset];
77305b2b:	81 e2 ff ff 00 00    	and    $0xffff,%edx

   return Source + (SHORT)Offset;
77305b31:	66 03 1c 51          	add    (%ecx,%edx,2),%bx
77305b35:	89 d8                	mov    %ebx,%eax
77305b37:	25 ff ff 00 00       	and    $0xffff,%eax
}
77305b3c:	5b                   	pop    %ebx
77305b3d:	5d                   	pop    %ebp
77305b3e:	c2 04 00             	ret    $0x4
77305b41:	eb 0d                	jmp    77305b50 <_RtlUpcaseUnicodeToCustomCPN@24>
77305b43:	90                   	nop    
77305b44:	90                   	nop    
77305b45:	90                   	nop    
77305b46:	90                   	nop    
77305b47:	90                   	nop    
77305b48:	90                   	nop    
77305b49:	90                   	nop    
77305b4a:	90                   	nop    
77305b4b:	90                   	nop    
77305b4c:	90                   	nop    
77305b4d:	90                   	nop    
77305b4e:	90                   	nop    
77305b4f:	90                   	nop    

77305b50 <_RtlUpcaseUnicodeToCustomCPN@24>:



/*
 * @unimplemented
 */
NTSTATUS STDCALL
RtlUpcaseUnicodeToCustomCPN (IN PCPTABLEINFO CustomCP,
                             PCHAR CustomString,
                             ULONG CustomSize,
                             PULONG ResultSize,
                             PWCHAR UnicodeString,
                             ULONG UnicodeSize)
{
77305b50:	55                   	push   %ebp
77305b51:	89 e5                	mov    %esp,%ebp
77305b53:	57                   	push   %edi
77305b54:	56                   	push   %esi
77305b55:	53                   	push   %ebx
77305b56:	83 ec 0c             	sub    $0xc,%esp
   WCHAR UpcaseChar;
   ULONG Size = 0;
   ULONG i;

   if (CustomCP->DBCSCodePage == 0)
77305b59:	8b 45 08             	mov    0x8(%ebp),%eax
77305b5c:	8b 7d 0c             	mov    0xc(%ebp),%edi
77305b5f:	8b 55 10             	mov    0x10(%ebp),%edx
77305b62:	8b 5d 14             	mov    0x14(%ebp),%ebx
77305b65:	8b 75 18             	mov    0x18(%ebp),%esi
77305b68:	8b 4d 1c             	mov    0x1c(%ebp),%ecx
77305b6b:	66 83 78 0c 00       	cmpw   $0x0,0xc(%eax)
77305b70:	75 4a                	jne    77305bbc <_RtlUpcaseUnicodeToCustomCPN@24+0x6c>
   {
      /* single-byte code page */
      if (UnicodeSize > (CustomSize * sizeof(WCHAR)))
77305b72:	8d 04 12             	lea    (%edx,%edx,1),%eax
77305b75:	39 c8                	cmp    %ecx,%eax
77305b77:	73 3d                	jae    77305bb6 <_RtlUpcaseUnicodeToCustomCPN@24+0x66>
         Size = CustomSize;
      else
         Size = UnicodeSize / sizeof(WCHAR);

      if (ResultSize != NULL)
77305b79:	85 db                	test   %ebx,%ebx
77305b7b:	74 02                	je     77305b7f <_RtlUpcaseUnicodeToCustomCPN@24+0x2f>
         *ResultSize = Size;
77305b7d:	89 13                	mov    %edx,(%ebx)

      for (i = 0; i < Size; i++)
77305b7f:	85 d2                	test   %edx,%edx
77305b81:	74 27                	je     77305baa <_RtlUpcaseUnicodeToCustomCPN@24+0x5a>
77305b83:	89 d3                	mov    %edx,%ebx
      {
         UpcaseChar = RtlUpcaseUnicodeChar(*UnicodeString);
77305b85:	66 8b 06             	mov    (%esi),%ax
         *CustomString = ((PCHAR)CustomCP->WideCharTable)[UpcaseChar];
         CustomString++;
         UnicodeString++;
77305b88:	83 c6 02             	add    $0x2,%esi
77305b8b:	25 ff ff 00 00       	and    $0xffff,%eax
77305b90:	50                   	push   %eax
77305b91:	e8 5a ff ff ff       	call   77305af0 <_RtlUpcaseUnicodeChar@4>
77305b96:	8b 4d 08             	mov    0x8(%ebp),%ecx
77305b99:	25 ff ff 00 00       	and    $0xffff,%eax
77305b9e:	8b 51 20             	mov    0x20(%ecx),%edx
77305ba1:	8a 04 10             	mov    (%eax,%edx,1),%al
77305ba4:	88 07                	mov    %al,(%edi)
77305ba6:	47                   	inc    %edi
77305ba7:	4b                   	dec    %ebx
77305ba8:	75 db                	jne    77305b85 <_RtlUpcaseUnicodeToCustomCPN@24+0x35>
      }
   }
   else
   {
      /* multi-byte code page */
      /* FIXME */
      ASSERT(FALSE);
   }

   return STATUS_SUCCESS;
}
77305baa:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77305bad:	31 c0                	xor    %eax,%eax
77305baf:	5b                   	pop    %ebx
77305bb0:	5e                   	pop    %esi
77305bb1:	5f                   	pop    %edi
77305bb2:	5d                   	pop    %ebp
77305bb3:	c2 18 00             	ret    $0x18
77305bb6:	89 ca                	mov    %ecx,%edx
77305bb8:	d1 ea                	shr    %edx
77305bba:	eb bd                	jmp    77305b79 <_RtlUpcaseUnicodeToCustomCPN@24+0x29>
77305bbc:	68 20 ab 30 77       	push   $0x7730ab20
77305bc1:	68 72 02 00 00       	push   $0x272
77305bc6:	68 21 ab 30 77       	push   $0x7730ab21
77305bcb:	68 27 ab 30 77       	push   $0x7730ab27
77305bd0:	e8 fb 16 00 00       	call   773072d0 <_RtlAssert@16>
77305bd5:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77305bd8:	31 c0                	xor    %eax,%eax
77305bda:	5b                   	pop    %ebx
77305bdb:	5e                   	pop    %esi
77305bdc:	5f                   	pop    %edi
77305bdd:	5d                   	pop    %ebp
77305bde:	c2 18 00             	ret    $0x18
77305be1:	eb 0d                	jmp    77305bf0 <_RtlUpcaseUnicodeToMultiByteN@20>
77305be3:	90                   	nop    
77305be4:	90                   	nop    
77305be5:	90                   	nop    
77305be6:	90                   	nop    
77305be7:	90                   	nop    
77305be8:	90                   	nop    
77305be9:	90                   	nop    
77305bea:	90                   	nop    
77305beb:	90                   	nop    
77305bec:	90                   	nop    
77305bed:	90                   	nop    
77305bee:	90                   	nop    
77305bef:	90                   	nop    

77305bf0 <_RtlUpcaseUnicodeToMultiByteN@20>:


/*
 * @unimplemented
 */
NTSTATUS STDCALL
RtlUpcaseUnicodeToMultiByteN (PCHAR MbString,
                              ULONG MbSize,
                              PULONG ResultSize,
                              PWCHAR UnicodeString,
                              ULONG UnicodeSize)
{
77305bf0:	55                   	push   %ebp
77305bf1:	89 e5                	mov    %esp,%ebp
77305bf3:	57                   	push   %edi
77305bf4:	56                   	push   %esi
77305bf5:	53                   	push   %ebx
77305bf6:	83 ec 0c             	sub    $0xc,%esp
77305bf9:	8b 7d 08             	mov    0x8(%ebp),%edi
77305bfc:	8b 55 0c             	mov    0xc(%ebp),%edx
77305bff:	8b 5d 10             	mov    0x10(%ebp),%ebx
77305c02:	8b 75 14             	mov    0x14(%ebp),%esi
77305c05:	8b 4d 18             	mov    0x18(%ebp),%ecx
   WCHAR UpcaseChar;
   ULONG Size = 0;
   ULONG i;

   if (NlsMbCodePageTag == FALSE)
77305c08:	80 3d 44 c0 30 77 00 	cmpb   $0x0,0x7730c044
77305c0f:	75 4a                	jne    77305c5b <_RtlUpcaseUnicodeToMultiByteN@20+0x6b>
   {
      /* single-byte code page */
      if (UnicodeSize > (MbSize * sizeof(WCHAR)))
77305c11:	8d 04 12             	lea    (%edx,%edx,1),%eax
77305c14:	39 c8                	cmp    %ecx,%eax
77305c16:	73 3d                	jae    77305c55 <_RtlUpcaseUnicodeToMultiByteN@20+0x65>
         Size = MbSize;
      else
         Size = UnicodeSize / sizeof(WCHAR);

      if (ResultSize != NULL)
77305c18:	85 db                	test   %ebx,%ebx
77305c1a:	74 02                	je     77305c1e <_RtlUpcaseUnicodeToMultiByteN@20+0x2e>
         *ResultSize = Size;
77305c1c:	89 13                	mov    %edx,(%ebx)

      for (i = 0; i < Size; i++)
77305c1e:	85 d2                	test   %edx,%edx
77305c20:	74 27                	je     77305c49 <_RtlUpcaseUnicodeToMultiByteN@20+0x59>
77305c22:	89 d3                	mov    %edx,%ebx
      {
         UpcaseChar = RtlUpcaseUnicodeChar(*UnicodeString);
77305c24:	66 8b 06             	mov    (%esi),%ax
         *MbString = NlsUnicodeToAnsiTable[UpcaseChar];
         MbString++;
         UnicodeString++;
77305c27:	83 c6 02             	add    $0x2,%esi
77305c2a:	25 ff ff 00 00       	and    $0xffff,%eax
77305c2f:	50                   	push   %eax
77305c30:	e8 bb fe ff ff       	call   77305af0 <_RtlUpcaseUnicodeChar@4>
77305c35:	8b 15 3c c0 30 77    	mov    0x7730c03c,%edx
77305c3b:	25 ff ff 00 00       	and    $0xffff,%eax
77305c40:	8a 04 02             	mov    (%edx,%eax,1),%al
77305c43:	88 07                	mov    %al,(%edi)
77305c45:	47                   	inc    %edi
77305c46:	4b                   	dec    %ebx
77305c47:	75 db                	jne    77305c24 <_RtlUpcaseUnicodeToMultiByteN@20+0x34>
      }
   }
   else
   {
      /* multi-byte code page */
      /* FIXME */
      ASSERT(FALSE);
   }

   return STATUS_SUCCESS;
}
77305c49:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77305c4c:	31 c0                	xor    %eax,%eax
77305c4e:	5b                   	pop    %ebx
77305c4f:	5e                   	pop    %esi
77305c50:	5f                   	pop    %edi
77305c51:	5d                   	pop    %ebp
77305c52:	c2 14 00             	ret    $0x14
77305c55:	89 ca                	mov    %ecx,%edx
77305c57:	d1 ea                	shr    %edx
77305c59:	eb bd                	jmp    77305c18 <_RtlUpcaseUnicodeToMultiByteN@20+0x28>
77305c5b:	68 20 ab 30 77       	push   $0x7730ab20
77305c60:	68 9e 02 00 00       	push   $0x29e
77305c65:	68 21 ab 30 77       	push   $0x7730ab21
77305c6a:	68 27 ab 30 77       	push   $0x7730ab27
77305c6f:	e8 5c 16 00 00       	call   773072d0 <_RtlAssert@16>
77305c74:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77305c77:	31 c0                	xor    %eax,%eax
77305c79:	5b                   	pop    %ebx
77305c7a:	5e                   	pop    %esi
77305c7b:	5f                   	pop    %edi
77305c7c:	5d                   	pop    %ebp
77305c7d:	c2 14 00             	ret    $0x14

77305c80 <_RtlUpcaseUnicodeToOemN@20>:


/*
 * @unimplemented
 */
NTSTATUS STDCALL
RtlUpcaseUnicodeToOemN (PCHAR OemString,
                        ULONG OemSize,
                        PULONG ResultSize,
                        PWCHAR UnicodeString,
                        ULONG UnicodeSize)
{
77305c80:	55                   	push   %ebp
77305c81:	89 e5                	mov    %esp,%ebp
77305c83:	57                   	push   %edi
77305c84:	56                   	push   %esi
77305c85:	53                   	push   %ebx
77305c86:	83 ec 0c             	sub    $0xc,%esp
77305c89:	8b 7d 08             	mov    0x8(%ebp),%edi
77305c8c:	8b 55 0c             	mov    0xc(%ebp),%edx
77305c8f:	8b 5d 10             	mov    0x10(%ebp),%ebx
77305c92:	8b 75 14             	mov    0x14(%ebp),%esi
77305c95:	8b 4d 18             	mov    0x18(%ebp),%ecx
   WCHAR UpcaseChar;
   ULONG Size = 0;
   ULONG i;

   if (NlsMbOemCodePageTag == FALSE)
77305c98:	80 3d 30 c0 30 77 00 	cmpb   $0x0,0x7730c030
77305c9f:	75 4a                	jne    77305ceb <_RtlUpcaseUnicodeToOemN@20+0x6b>
   {
      /* single-byte code page */
      if (UnicodeSize > (OemSize * sizeof(WCHAR)))
77305ca1:	8d 04 12             	lea    (%edx,%edx,1),%eax
77305ca4:	39 c8                	cmp    %ecx,%eax
77305ca6:	73 3d                	jae    77305ce5 <_RtlUpcaseUnicodeToOemN@20+0x65>
         Size = OemSize;
      else
         Size = UnicodeSize / sizeof(WCHAR);

      if (ResultSize != NULL)
77305ca8:	85 db                	test   %ebx,%ebx
77305caa:	74 02                	je     77305cae <_RtlUpcaseUnicodeToOemN@20+0x2e>
         *ResultSize = Size;
77305cac:	89 13                	mov    %edx,(%ebx)

      for (i = 0; i < Size; i++)
77305cae:	85 d2                	test   %edx,%edx
77305cb0:	74 27                	je     77305cd9 <_RtlUpcaseUnicodeToOemN@20+0x59>
77305cb2:	89 d3                	mov    %edx,%ebx
      {
         UpcaseChar = RtlUpcaseUnicodeChar(*UnicodeString);
77305cb4:	66 8b 06             	mov    (%esi),%ax
         *OemString = NlsUnicodeToOemTable[UpcaseChar];
         OemString++;
         UnicodeString++;
77305cb7:	83 c6 02             	add    $0x2,%esi
77305cba:	25 ff ff 00 00       	and    $0xffff,%eax
77305cbf:	50                   	push   %eax
77305cc0:	e8 2b fe ff ff       	call   77305af0 <_RtlUpcaseUnicodeChar@4>
77305cc5:	8b 15 28 c0 30 77    	mov    0x7730c028,%edx
77305ccb:	25 ff ff 00 00       	and    $0xffff,%eax
77305cd0:	8a 04 02             	mov    (%edx,%eax,1),%al
77305cd3:	88 07                	mov    %al,(%edi)
77305cd5:	47                   	inc    %edi
77305cd6:	4b                   	dec    %ebx
77305cd7:	75 db                	jne    77305cb4 <_RtlUpcaseUnicodeToOemN@20+0x34>
      }
   }
   else
   {
      /* multi-byte code page */
      /* FIXME */
      ASSERT(FALSE);
   }

   return STATUS_SUCCESS;
}
77305cd9:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77305cdc:	31 c0                	xor    %eax,%eax
77305cde:	5b                   	pop    %ebx
77305cdf:	5e                   	pop    %esi
77305ce0:	5f                   	pop    %edi
77305ce1:	5d                   	pop    %ebp
77305ce2:	c2 14 00             	ret    $0x14
77305ce5:	89 ca                	mov    %ecx,%edx
77305ce7:	d1 ea                	shr    %edx
77305ce9:	eb bd                	jmp    77305ca8 <_RtlUpcaseUnicodeToOemN@20+0x28>
77305ceb:	68 20 ab 30 77       	push   $0x7730ab20
77305cf0:	68 ca 02 00 00       	push   $0x2ca
77305cf5:	68 21 ab 30 77       	push   $0x7730ab21
77305cfa:	68 27 ab 30 77       	push   $0x7730ab27
77305cff:	e8 cc 15 00 00       	call   773072d0 <_RtlAssert@16>
77305d04:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77305d07:	31 c0                	xor    %eax,%eax
77305d09:	5b                   	pop    %ebx
77305d0a:	5e                   	pop    %esi
77305d0b:	5f                   	pop    %edi
77305d0c:	5d                   	pop    %ebp
77305d0d:	c2 14 00             	ret    $0x14

77305d10 <_RtlUpperChar@4>:



/*
 * @unimplemented
 */
CHAR STDCALL
RtlUpperChar (IN CHAR Source)
{
77305d10:	55                   	push   %ebp
77305d11:	89 e5                	mov    %esp,%ebp
   WCHAR Unicode;
   CHAR Destination;

   if (NlsMbCodePageTag == FALSE)
77305d13:	80 3d 44 c0 30 77 00 	cmpb   $0x0,0x7730c044
77305d1a:	8b 45 08             	mov    0x8(%ebp),%eax
77305d1d:	88 c2                	mov    %al,%dl
77305d1f:	75 28                	jne    77305d49 <_RtlUpperChar@4+0x39>
   {
      /* single-byte code page */

      /* ansi->unicode */
      Unicode = NlsAnsiToUnicodeTable[(UCHAR)Source];
77305d21:	81 e2 ff 00 00 00    	and    $0xff,%edx
77305d27:	a1 40 c0 30 77       	mov    0x7730c040,%eax
77305d2c:	66 8b 04 50          	mov    (%eax,%edx,2),%ax

      /* upcase conversion */
      Unicode = RtlUpcaseUnicodeChar (Unicode);
77305d30:	25 ff ff 00 00       	and    $0xffff,%eax
77305d35:	50                   	push   %eax
77305d36:	e8 b5 fd ff ff       	call   77305af0 <_RtlUpcaseUnicodeChar@4>

      /* unicode -> ansi */
      Destination = NlsUnicodeToAnsiTable[(USHORT)Unicode];
77305d3b:	8b 15 3c c0 30 77    	mov    0x7730c03c,%edx
77305d41:	25 ff ff 00 00       	and    $0xffff,%eax
77305d46:	8a 04 02             	mov    (%edx,%eax,1),%al
   }
   else
   {
      /* multi-byte code page */
      /* FIXME */
      Destination = Source;
   }

   return Destination;
77305d49:	0f be c0             	movsbl %al,%eax
}
77305d4c:	c9                   	leave  
77305d4d:	c2 04 00             	ret    $0x4

77305d50 <_HEAP_Dump>:
77305d50:	55                   	push   %ebp
77305d51:	89 e5                	mov    %esp,%ebp
77305d53:	53                   	push   %ebx
77305d54:	8b 55 08             	mov    0x8(%ebp),%edx
77305d57:	8b 42 0c             	mov    0xc(%edx),%eax
77305d5a:	eb 07                	jmp    77305d63 <_HEAP_Dump+0x13>
77305d5c:	8d 74 26 00          	lea    0x0(%esi),%esi
77305d60:	8b 40 0c             	mov    0xc(%eax),%eax
77305d63:	85 c0                	test   %eax,%eax
77305d65:	75 f9                	jne    77305d60 <_HEAP_Dump+0x10>
77305d67:	89 d1                	mov    %edx,%ecx
77305d69:	85 c9                	test   %ecx,%ecx
77305d6b:	74 2c                	je     77305d99 <_HEAP_Dump+0x49>
77305d6d:	8d 76 00             	lea    0x0(%esi),%esi
77305d70:	8b 51 08             	mov    0x8(%ecx),%edx
77305d73:	8b 19                	mov    (%ecx),%ebx
77305d75:	01 ca                	add    %ecx,%edx
77305d77:	8d 04 0b             	lea    (%ebx,%ecx,1),%eax
77305d7a:	39 d0                	cmp    %edx,%eax
77305d7c:	76 14                	jbe    77305d92 <_HEAP_Dump+0x42>
77305d7e:	8b 02                	mov    (%edx),%eax
77305d80:	a8 01                	test   $0x1,%al
77305d82:	74 1c                	je     77305da0 <_HEAP_Dump+0x50>
77305d84:	83 e0 fc             	and    $0xfffffffc,%eax
77305d87:	8d 54 10 10          	lea    0x10(%eax,%edx,1),%edx
77305d8b:	8d 04 0b             	lea    (%ebx,%ecx,1),%eax
77305d8e:	39 d0                	cmp    %edx,%eax
77305d90:	77 ec                	ja     77305d7e <_HEAP_Dump+0x2e>
77305d92:	8b 49 0c             	mov    0xc(%ecx),%ecx
77305d95:	85 c9                	test   %ecx,%ecx
77305d97:	75 d7                	jne    77305d70 <_HEAP_Dump+0x20>
77305d99:	5b                   	pop    %ebx
77305d9a:	5d                   	pop    %ebp
77305d9b:	c3                   	ret    
77305d9c:	8d 74 26 00          	lea    0x0(%esi),%esi
77305da0:	83 e0 fc             	and    $0xfffffffc,%eax
77305da3:	8d 54 10 08          	lea    0x8(%eax,%edx,1),%edx
77305da7:	eb ce                	jmp    77305d77 <_HEAP_Dump+0x27>
77305da9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

77305db0 <_HEAP_GetPtr>:
77305db0:	55                   	push   %ebp
77305db1:	85 c0                	test   %eax,%eax
77305db3:	89 e5                	mov    %esp,%ebp
77305db5:	74 0c                	je     77305dc3 <_HEAP_GetPtr+0x13>
77305db7:	81 b8 88 00 00 00 48 	cmpl   $0x50414548,0x88(%eax)
77305dbe:	45 41 50 
77305dc1:	74 02                	je     77305dc5 <_HEAP_GetPtr+0x15>
77305dc3:	31 c0                	xor    %eax,%eax
77305dc5:	5d                   	pop    %ebp
77305dc6:	c3                   	ret    
77305dc7:	89 f6                	mov    %esi,%esi
77305dc9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77305dd0 <_HEAP_FindSubHeap>:
77305dd0:	55                   	push   %ebp
77305dd1:	89 c1                	mov    %eax,%ecx
77305dd3:	89 e5                	mov    %esp,%ebp
77305dd5:	85 c9                	test   %ecx,%ecx
77305dd7:	74 1a                	je     77305df3 <_HEAP_FindSubHeap+0x23>
77305dd9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
77305de0:	39 ca                	cmp    %ecx,%edx
77305de2:	72 08                	jb     77305dec <_HEAP_FindSubHeap+0x1c>
77305de4:	8b 01                	mov    (%ecx),%eax
77305de6:	01 c8                	add    %ecx,%eax
77305de8:	39 d0                	cmp    %edx,%eax
77305dea:	77 0b                	ja     77305df7 <_HEAP_FindSubHeap+0x27>
77305dec:	8b 49 0c             	mov    0xc(%ecx),%ecx
77305def:	85 c9                	test   %ecx,%ecx
77305df1:	75 ed                	jne    77305de0 <_HEAP_FindSubHeap+0x10>
77305df3:	31 c0                	xor    %eax,%eax
77305df5:	5d                   	pop    %ebp
77305df6:	c3                   	ret    
77305df7:	89 c8                	mov    %ecx,%eax
77305df9:	5d                   	pop    %ebp
77305dfa:	c3                   	ret    
77305dfb:	90                   	nop    
77305dfc:	8d 74 26 00          	lea    0x0(%esi),%esi

77305e00 <_HEAP_CreateFreeBlock>:
77305e00:	55                   	push   %ebp
77305e01:	89 e5                	mov    %esp,%ebp
77305e03:	57                   	push   %edi
77305e04:	56                   	push   %esi
77305e05:	53                   	push   %ebx
77305e06:	89 d3                	mov    %edx,%ebx
77305e08:	57                   	push   %edi
77305e09:	57                   	push   %edi
77305e0a:	89 c7                	mov    %eax,%edi
 struct _TEB * pTeb;

#if defined(__GNUC__)
 /* FIXME: instead of hardcoded offsets, use offsetof() - if possible */
 __asm__ __volatile__
77305e0c:	64 a1 18 00 00 00    	mov    %fs:0x18,%eax
77305e12:	8b 40 24             	mov    0x24(%eax),%eax
77305e15:	66 c7 42 06 46 48    	movw   $0x4846,0x6(%edx)

#if defined(_M_IX86)
/* on the x86, the TEB is contained in the FS segment */
static inline struct _TEB * NtCurrentTeb(void)
{
77305e1b:	66 89 42 04          	mov    %ax,0x4(%edx)
77305e1f:	8b 45 08             	mov    0x8(%ebp),%eax
77305e22:	8d 0c 02             	lea    (%edx,%eax,1),%ecx
77305e25:	8b 07                	mov    (%edi),%eax
77305e27:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
77305e2a:	01 f8                	add    %edi,%eax
77305e2c:	39 c1                	cmp    %eax,%ecx
77305e2e:	73 10                	jae    77305e40 <_HEAP_CreateFreeBlock+0x40>
77305e30:	8b 31                	mov    (%ecx),%esi
77305e32:	f7 c6 01 00 00 00    	test   $0x1,%esi
77305e38:	75 6b                	jne    77305ea5 <_HEAP_CreateFreeBlock+0xa5>
77305e3a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77305e40:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
77305e43:	01 f8                	add    %edi,%eax
77305e45:	39 c1                	cmp    %eax,%ecx
77305e47:	0f 93 45 f3          	setae  0xfffffff3(%ebp)
77305e4b:	80 7d f3 00          	cmpb   $0x0,0xfffffff3(%ebp)
77305e4f:	75 0a                	jne    77305e5b <_HEAP_CreateFreeBlock+0x5b>
77305e51:	8b 31                	mov    (%ecx),%esi
77305e53:	89 59 fc             	mov    %ebx,0xfffffffc(%ecx)
77305e56:	83 ce 02             	or     $0x2,%esi
77305e59:	89 31                	mov    %esi,(%ecx)
77305e5b:	8b 4d 08             	mov    0x8(%ebp),%ecx
77305e5e:	8b 47 10             	mov    0x10(%edi),%eax
77305e61:	83 e9 10             	sub    $0x10,%ecx
77305e64:	89 0b                	mov    %ecx,(%ebx)
77305e66:	8d 70 1c             	lea    0x1c(%eax),%esi
77305e69:	39 48 1c             	cmp    %ecx,0x1c(%eax)
77305e6c:	89 f2                	mov    %esi,%edx
77305e6e:	eb 05                	jmp    77305e75 <_HEAP_CreateFreeBlock+0x75>
77305e70:	83 c2 14             	add    $0x14,%edx
77305e73:	39 0a                	cmp    %ecx,(%edx)
77305e75:	72 f9                	jb     77305e70 <_HEAP_CreateFreeBlock+0x70>
77305e77:	80 7d f3 00          	cmpb   $0x0,0xfffffff3(%ebp)
77305e7b:	74 4c                	je     77305ec9 <_HEAP_CreateFreeBlock+0xc9>
77305e7d:	83 c2 14             	add    $0x14,%edx
77305e80:	83 c0 6c             	add    $0x6c,%eax
77305e83:	39 d0                	cmp    %edx,%eax
77305e85:	74 60                	je     77305ee7 <_HEAP_CreateFreeBlock+0xe7>
77305e87:	8b 42 10             	mov    0x10(%edx),%eax
77305e8a:	83 c9 01             	or     $0x1,%ecx
77305e8d:	89 43 0c             	mov    %eax,0xc(%ebx)
77305e90:	89 0b                	mov    %ecx,(%ebx)
77305e92:	89 58 08             	mov    %ebx,0x8(%eax)
77305e95:	8d 42 04             	lea    0x4(%edx),%eax
77305e98:	89 43 08             	mov    %eax,0x8(%ebx)
77305e9b:	89 5a 10             	mov    %ebx,0x10(%edx)
77305e9e:	58                   	pop    %eax
77305e9f:	5a                   	pop    %edx
77305ea0:	5b                   	pop    %ebx
77305ea1:	5e                   	pop    %esi
77305ea2:	5f                   	pop    %edi
77305ea3:	5d                   	pop    %ebp
77305ea4:	c3                   	ret    
77305ea5:	8b 41 08             	mov    0x8(%ecx),%eax
77305ea8:	8b 51 0c             	mov    0xc(%ecx),%edx
77305eab:	83 e6 fc             	and    $0xfffffffc,%esi
77305eae:	89 50 0c             	mov    %edx,0xc(%eax)
77305eb1:	8b 51 0c             	mov    0xc(%ecx),%edx
77305eb4:	89 42 08             	mov    %eax,0x8(%edx)
77305eb7:	8b 45 08             	mov    0x8(%ebp),%eax
77305eba:	8d 44 06 10          	lea    0x10(%esi,%eax,1),%eax
77305ebe:	89 45 08             	mov    %eax,0x8(%ebp)
77305ec1:	8d 0c 03             	lea    (%ebx,%eax,1),%ecx
77305ec4:	e9 77 ff ff ff       	jmp    77305e40 <_HEAP_CreateFreeBlock+0x40>
77305ec9:	8b 42 0c             	mov    0xc(%edx),%eax
77305ecc:	83 c9 01             	or     $0x1,%ecx
77305ecf:	89 43 08             	mov    %eax,0x8(%ebx)
77305ed2:	89 0b                	mov    %ecx,(%ebx)
77305ed4:	89 58 0c             	mov    %ebx,0xc(%eax)
77305ed7:	8d 42 04             	lea    0x4(%edx),%eax
77305eda:	89 43 0c             	mov    %eax,0xc(%ebx)
77305edd:	89 5a 0c             	mov    %ebx,0xc(%edx)
77305ee0:	58                   	pop    %eax
77305ee1:	5a                   	pop    %edx
77305ee2:	5b                   	pop    %ebx
77305ee3:	5e                   	pop    %esi
77305ee4:	5f                   	pop    %edi
77305ee5:	5d                   	pop    %ebp
77305ee6:	c3                   	ret    
77305ee7:	89 f2                	mov    %esi,%edx
77305ee9:	eb 9c                	jmp    77305e87 <_HEAP_CreateFreeBlock+0x87>
77305eeb:	90                   	nop    
77305eec:	8d 74 26 00          	lea    0x0(%esi),%esi

77305ef0 <_HEAP_MakeInUseBlockFree>:
77305ef0:	55                   	push   %ebp
77305ef1:	89 d1                	mov    %edx,%ecx
77305ef3:	89 e5                	mov    %esp,%ebp
77305ef5:	56                   	push   %esi
77305ef6:	53                   	push   %ebx
77305ef7:	89 cb                	mov    %ecx,%ebx
77305ef9:	83 ec 10             	sub    $0x10,%esp
77305efc:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
77305eff:	8b 12                	mov    (%edx),%edx
77305f01:	c7 45 f4 00 00 00 00 	movl   $0x0,0xfffffff4(%ebp)
77305f08:	89 d0                	mov    %edx,%eax
77305f0a:	83 e0 fc             	and    $0xfffffffc,%eax
77305f0d:	83 e2 02             	and    $0x2,%edx
77305f10:	8d 70 08             	lea    0x8(%eax),%esi
77305f13:	74 1b                	je     77305f30 <_HEAP_MakeInUseBlockFree+0x40>
77305f15:	8b 59 fc             	mov    0xfffffffc(%ecx),%ebx
77305f18:	8b 03                	mov    (%ebx),%eax
77305f1a:	8b 53 08             	mov    0x8(%ebx),%edx
77305f1d:	83 e0 fc             	and    $0xfffffffc,%eax
77305f20:	8d 74 30 10          	lea    0x10(%eax,%esi,1),%esi
77305f24:	8b 43 0c             	mov    0xc(%ebx),%eax
77305f27:	89 42 0c             	mov    %eax,0xc(%edx)
77305f2a:	8b 43 0c             	mov    0xc(%ebx),%eax
77305f2d:	89 50 08             	mov    %edx,0x8(%eax)
77305f30:	83 ec 0c             	sub    $0xc,%esp
77305f33:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
77305f36:	89 da                	mov    %ebx,%edx
77305f38:	56                   	push   %esi
77305f39:	e8 c2 fe ff ff       	call   77305e00 <_HEAP_CreateFreeBlock>
77305f3e:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
77305f41:	8b 03                	mov    (%ebx),%eax
77305f43:	83 e0 fc             	and    $0xfffffffc,%eax
77305f46:	83 c4 10             	add    $0x10,%esp
77305f49:	8b 11                	mov    (%ecx),%edx
77305f4b:	8d 44 18 10          	lea    0x10(%eax,%ebx,1),%eax
77305f4f:	01 ca                	add    %ecx,%edx
77305f51:	39 d0                	cmp    %edx,%eax
77305f53:	72 09                	jb     77305f5e <_HEAP_MakeInUseBlockFree+0x6e>
77305f55:	8b 41 08             	mov    0x8(%ecx),%eax
77305f58:	01 c8                	add    %ecx,%eax
77305f5a:	39 d8                	cmp    %ebx,%eax
77305f5c:	74 07                	je     77305f65 <_HEAP_MakeInUseBlockFree+0x75>
77305f5e:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
77305f61:	5b                   	pop    %ebx
77305f62:	5e                   	pop    %esi
77305f63:	5d                   	pop    %ebp
77305f64:	c3                   	ret    
77305f65:	8b 41 10             	mov    0x10(%ecx),%eax
77305f68:	39 c8                	cmp    %ecx,%eax
77305f6a:	74 f2                	je     77305f5e <_HEAP_MakeInUseBlockFree+0x6e>
77305f6c:	89 c6                	mov    %eax,%esi
77305f6e:	8b 43 08             	mov    0x8(%ebx),%eax
77305f71:	8b 53 0c             	mov    0xc(%ebx),%edx
77305f74:	85 f6                	test   %esi,%esi
77305f76:	89 50 0c             	mov    %edx,0xc(%eax)
77305f79:	8b 53 0c             	mov    0xc(%ebx),%edx
77305f7c:	89 42 08             	mov    %eax,0x8(%edx)
77305f7f:	74 0d                	je     77305f8e <_HEAP_MakeInUseBlockFree+0x9e>
77305f81:	8b 46 0c             	mov    0xc(%esi),%eax
77305f84:	39 c8                	cmp    %ecx,%eax
77305f86:	74 23                	je     77305fab <_HEAP_MakeInUseBlockFree+0xbb>
77305f88:	89 c6                	mov    %eax,%esi
77305f8a:	85 f6                	test   %esi,%esi
77305f8c:	75 f3                	jne    77305f81 <_HEAP_MakeInUseBlockFree+0x91>
77305f8e:	8d 45 f4             	lea    0xfffffff4(%ebp),%eax
77305f91:	c7 41 14 00 00 00 00 	movl   $0x0,0x14(%ecx)
77305f98:	68 00 80 00 00       	push   $0x8000
77305f9d:	50                   	push   %eax
77305f9e:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
77305fa1:	50                   	push   %eax
77305fa2:	6a ff                	push   $0xffffffff
77305fa4:	e8 37 1a 00 00       	call   773079e0 <_ZwFreeVirtualMemory@16>
77305fa9:	eb b3                	jmp    77305f5e <_HEAP_MakeInUseBlockFree+0x6e>
77305fab:	85 f6                	test   %esi,%esi
77305fad:	74 df                	je     77305f8e <_HEAP_MakeInUseBlockFree+0x9e>
77305faf:	8b 41 0c             	mov    0xc(%ecx),%eax
77305fb2:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
77305fb5:	89 46 0c             	mov    %eax,0xc(%esi)
77305fb8:	eb d4                	jmp    77305f8e <_HEAP_MakeInUseBlockFree+0x9e>
77305fba:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

77305fc0 <_HEAP_ShrinkBlock>:
77305fc0:	55                   	push   %ebp
77305fc1:	89 e5                	mov    %esp,%ebp
77305fc3:	57                   	push   %edi
77305fc4:	56                   	push   %esi
77305fc5:	53                   	push   %ebx
77305fc6:	83 ec 0c             	sub    $0xc,%esp
77305fc9:	89 c3                	mov    %eax,%ebx
77305fcb:	8b 7d 08             	mov    0x8(%ebp),%edi
77305fce:	8b 0a                	mov    (%edx),%ecx
77305fd0:	83 e1 fc             	and    $0xfffffffc,%ecx
77305fd3:	89 d6                	mov    %edx,%esi
77305fd5:	8d 47 18             	lea    0x18(%edi),%eax
77305fd8:	39 c1                	cmp    %eax,%ecx
77305fda:	73 24                	jae    77306000 <_HEAP_ShrinkBlock+0x40>
77305fdc:	8d 14 11             	lea    (%ecx,%edx,1),%edx
77305fdf:	8b 0b                	mov    (%ebx),%ecx
77305fe1:	01 cb                	add    %ecx,%ebx
77305fe3:	8d 42 08             	lea    0x8(%edx),%eax
77305fe6:	39 c3                	cmp    %eax,%ebx
77305fe8:	76 09                	jbe    77305ff3 <_HEAP_ShrinkBlock+0x33>
77305fea:	8b 42 08             	mov    0x8(%edx),%eax
77305fed:	83 e0 fd             	and    $0xfffffffd,%eax
77305ff0:	89 42 08             	mov    %eax,0x8(%edx)
77305ff3:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77305ff6:	5b                   	pop    %ebx
77305ff7:	5e                   	pop    %esi
77305ff8:	5f                   	pop    %edi
77305ff9:	5d                   	pop    %ebp
77305ffa:	c3                   	ret    
77305ffb:	90                   	nop    
77305ffc:	8d 74 26 00          	lea    0x0(%esi),%esi
77306000:	83 ec 0c             	sub    $0xc,%esp
77306003:	29 f9                	sub    %edi,%ecx
77306005:	89 d8                	mov    %ebx,%eax
77306007:	8d 54 3a 08          	lea    0x8(%edx,%edi,1),%edx
7730600b:	51                   	push   %ecx
7730600c:	e8 ef fd ff ff       	call   77305e00 <_HEAP_CreateFreeBlock>
77306011:	8b 06                	mov    (%esi),%eax
77306013:	83 c4 10             	add    $0x10,%esp
77306016:	83 e0 03             	and    $0x3,%eax
77306019:	09 f8                	or     %edi,%eax
7730601b:	89 06                	mov    %eax,(%esi)
7730601d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77306020:	5b                   	pop    %ebx
77306021:	5e                   	pop    %esi
77306022:	5f                   	pop    %edi
77306023:	5d                   	pop    %ebp
77306024:	c3                   	ret    
77306025:	8d 74 26 00          	lea    0x0(%esi),%esi
77306029:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77306030 <_HEAP_CreateSubHeap>:
77306030:	55                   	push   %ebp
77306031:	89 e5                	mov    %esp,%ebp
77306033:	57                   	push   %edi
77306034:	56                   	push   %esi
77306035:	53                   	push   %ebx
77306036:	83 ec 1c             	sub    $0x1c,%esp
77306039:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
7730603c:	8b 45 0c             	mov    0xc(%ebp),%eax
7730603f:	8b 75 10             	mov    0x10(%ebp),%esi
77306042:	05 ff ff 00 00       	add    $0xffff,%eax
77306047:	81 c6 ff ff 00 00    	add    $0xffff,%esi
7730604d:	89 c3                	mov    %eax,%ebx
7730604f:	81 e6 00 00 ff ff    	and    $0xffff0000,%esi
77306055:	81 e3 00 00 ff ff    	and    $0xffff0000,%ebx
7730605b:	89 d7                	mov    %edx,%edi
7730605d:	75 05                	jne    77306064 <_HEAP_CreateSubHeap+0x34>
7730605f:	bb 00 00 01 00       	mov    $0x10000,%ebx
77306064:	39 de                	cmp    %ebx,%esi
77306066:	73 02                	jae    7730606a <_HEAP_CreateSubHeap+0x3a>
77306068:	89 de                	mov    %ebx,%esi
7730606a:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
7730606d:	89 75 10             	mov    %esi,0x10(%ebp)
77306070:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
77306073:	85 c0                	test   %eax,%eax
77306075:	0f 84 3a 01 00 00    	je     773061b5 <_HEAP_CreateSubHeap+0x185>
7730607b:	85 ff                	test   %edi,%edi
7730607d:	0f 84 83 00 00 00    	je     77306106 <_HEAP_CreateSubHeap+0xd6>
77306083:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
77306086:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
77306089:	89 5d ec             	mov    %ebx,0xffffffec(%ebp)
7730608c:	53                   	push   %ebx
7730608d:	53                   	push   %ebx
7730608e:	6a 40                	push   $0x40
77306090:	68 00 10 00 00       	push   $0x1000
77306095:	50                   	push   %eax
77306096:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
77306099:	6a 00                	push   $0x0
7730609b:	50                   	push   %eax
7730609c:	6a ff                	push   $0xffffffff
7730609e:	e8 4d 19 00 00       	call   773079f0 <_ZwAllocateVirtualMemory@24>
773060a3:	5a                   	pop    %edx
773060a4:	31 d2                	xor    %edx,%edx
773060a6:	59                   	pop    %ecx
773060a7:	85 c0                	test   %eax,%eax
773060a9:	78 46                	js     773060f1 <_HEAP_CreateSubHeap+0xc1>
773060ab:	8b 5d e8             	mov    0xffffffe8(%ebp),%ebx
773060ae:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
773060b1:	89 f1                	mov    %esi,%ecx
773060b3:	39 fb                	cmp    %edi,%ebx
773060b5:	89 7b 10             	mov    %edi,0x10(%ebx)
773060b8:	89 33                	mov    %esi,(%ebx)
773060ba:	89 43 04             	mov    %eax,0x4(%ebx)
773060bd:	c7 43 14 53 55 42 48 	movl   $0x48425553,0x14(%ebx)
773060c4:	74 4a                	je     77306110 <_HEAP_CreateSubHeap+0xe0>
773060c6:	8b 47 0c             	mov    0xc(%edi),%eax
773060c9:	c7 43 08 18 00 00 00 	movl   $0x18,0x8(%ebx)
773060d0:	89 43 0c             	mov    %eax,0xc(%ebx)
773060d3:	89 5f 0c             	mov    %ebx,0xc(%edi)
773060d6:	8b 43 08             	mov    0x8(%ebx),%eax
773060d9:	83 ec 0c             	sub    $0xc,%esp
773060dc:	29 c1                	sub    %eax,%ecx
773060de:	8d 14 18             	lea    (%eax,%ebx,1),%edx
773060e1:	51                   	push   %ecx
773060e2:	89 d8                	mov    %ebx,%eax
773060e4:	e8 17 fd ff ff       	call   77305e00 <_HEAP_CreateFreeBlock>
773060e9:	83 c4 10             	add    $0x10,%esp
773060ec:	ba 01 00 00 00       	mov    $0x1,%edx
773060f1:	85 d2                	test   %edx,%edx
773060f3:	0f 84 ae 00 00 00    	je     773061a7 <_HEAP_CreateSubHeap+0x177>
773060f9:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
773060fc:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773060ff:	89 d0                	mov    %edx,%eax
77306101:	5b                   	pop    %ebx
77306102:	5e                   	pop    %esi
77306103:	5f                   	pop    %edi
77306104:	5d                   	pop    %ebp
77306105:	c3                   	ret    
77306106:	89 c7                	mov    %eax,%edi
77306108:	e9 76 ff ff ff       	jmp    77306083 <_HEAP_CreateSubHeap+0x53>
7730610d:	8d 76 00             	lea    0x0(%esi),%esi
77306110:	8b 45 08             	mov    0x8(%ebp),%eax
77306113:	c7 43 08 90 00 00 00 	movl   $0x90,0x8(%ebx)
7730611a:	c7 43 0c 00 00 00 00 	movl   $0x0,0xc(%ebx)
77306121:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)
77306128:	89 83 84 00 00 00    	mov    %eax,0x84(%ebx)
7730612e:	c7 83 88 00 00 00 48 	movl   $0x50414548,0x88(%ebx)
77306135:	45 41 50 
77306138:	31 c9                	xor    %ecx,%ecx
7730613a:	8d 53 1c             	lea    0x1c(%ebx),%edx
7730613d:	89 5d dc             	mov    %ebx,0xffffffdc(%ebp)
77306140:	89 de                	mov    %ebx,%esi
77306142:	8b 04 8d 30 ab 30 77 	mov    0x7730ab30(,%ecx,4),%eax
77306149:	c7 42 04 01 00 00 00 	movl   $0x1,0x4(%edx)
77306150:	89 02                	mov    %eax,(%edx)
77306152:	83 f9 02             	cmp    $0x2,%ecx
77306155:	8d 46 34             	lea    0x34(%esi),%eax
77306158:	7e 03                	jle    7730615d <_HEAP_CreateSubHeap+0x12d>
7730615a:	8d 47 20             	lea    0x20(%edi),%eax
7730615d:	89 42 0c             	mov    %eax,0xc(%edx)
77306160:	85 c9                	test   %ecx,%ecx
77306162:	8d 47 5c             	lea    0x5c(%edi),%eax
77306165:	74 06                	je     7730616d <_HEAP_CreateSubHeap+0x13d>
77306167:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
7730616a:	83 c0 0c             	add    $0xc,%eax
7730616d:	89 42 10             	mov    %eax,0x10(%edx)
77306170:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
77306173:	83 c0 14             	add    $0x14,%eax
77306176:	41                   	inc    %ecx
77306177:	66 c7 42 08 00 00    	movw   $0x0,0x8(%edx)
7730617d:	66 c7 42 0a 46 48    	movw   $0x4846,0xa(%edx)
77306183:	83 c6 14             	add    $0x14,%esi
77306186:	83 c2 14             	add    $0x14,%edx
77306189:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
7730618c:	83 f9 03             	cmp    $0x3,%ecx
7730618f:	7e b1                	jle    77306142 <_HEAP_CreateSubHeap+0x112>
77306191:	83 ec 0c             	sub    $0xc,%esp
77306194:	8d 47 6c             	lea    0x6c(%edi),%eax
77306197:	50                   	push   %eax
77306198:	e8 63 18 00 00       	call   77307a00 <_RtlInitializeCriticalSection@4>
7730619d:	8b 0b                	mov    (%ebx),%ecx
7730619f:	83 c4 0c             	add    $0xc,%esp
773061a2:	e9 2f ff ff ff       	jmp    773060d6 <_HEAP_CreateSubHeap+0xa6>
773061a7:	8b 5d e0             	mov    0xffffffe0(%ebp),%ebx
773061aa:	85 db                	test   %ebx,%ebx
773061ac:	74 38                	je     773061e6 <_HEAP_CreateSubHeap+0x1b6>
773061ae:	31 d2                	xor    %edx,%edx
773061b0:	e9 47 ff ff ff       	jmp    773060fc <_HEAP_CreateSubHeap+0xcc>
773061b5:	8d 45 10             	lea    0x10(%ebp),%eax
773061b8:	51                   	push   %ecx
773061b9:	51                   	push   %ecx
773061ba:	6a 40                	push   $0x40
773061bc:	68 00 30 00 00       	push   $0x3000
773061c1:	50                   	push   %eax
773061c2:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
773061c5:	6a 00                	push   $0x0
773061c7:	50                   	push   %eax
773061c8:	6a ff                	push   $0xffffffff
773061ca:	e8 21 18 00 00       	call   773079f0 <_ZwAllocateVirtualMemory@24>
773061cf:	5e                   	pop    %esi
773061d0:	5a                   	pop    %edx
773061d1:	31 d2                	xor    %edx,%edx
773061d3:	85 c0                	test   %eax,%eax
773061d5:	0f 88 21 ff ff ff    	js     773060fc <_HEAP_CreateSubHeap+0xcc>
773061db:	8b 75 10             	mov    0x10(%ebp),%esi
773061de:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
773061e1:	e9 95 fe ff ff       	jmp    7730607b <_HEAP_CreateSubHeap+0x4b>
773061e6:	8d 45 e4             	lea    0xffffffe4(%ebp),%eax
773061e9:	68 00 80 00 00       	push   $0x8000
773061ee:	50                   	push   %eax
773061ef:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
773061f2:	50                   	push   %eax
773061f3:	c7 45 e4 00 00 00 00 	movl   $0x0,0xffffffe4(%ebp)
773061fa:	6a ff                	push   $0xffffffff
773061fc:	e8 df 17 00 00       	call   773079e0 <_ZwFreeVirtualMemory@16>
77306201:	31 d2                	xor    %edx,%edx
77306203:	e9 f4 fe ff ff       	jmp    773060fc <_HEAP_CreateSubHeap+0xcc>
77306208:	90                   	nop    
77306209:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

77306210 <_HEAP_FindFreeBlock>:
77306210:	55                   	push   %ebp
77306211:	89 c1                	mov    %eax,%ecx
77306213:	89 e5                	mov    %esp,%ebp
77306215:	57                   	push   %edi
77306216:	56                   	push   %esi
77306217:	53                   	push   %ebx
77306218:	83 ec 0c             	sub    $0xc,%esp
7730621b:	89 d6                	mov    %edx,%esi
7730621d:	39 51 1c             	cmp    %edx,0x1c(%ecx)
77306220:	8d 40 1c             	lea    0x1c(%eax),%eax
77306223:	eb 05                	jmp    7730622a <_HEAP_FindFreeBlock+0x1a>
77306225:	83 c0 14             	add    $0x14,%eax
77306228:	39 30                	cmp    %esi,(%eax)
7730622a:	72 f9                	jb     77306225 <_HEAP_FindFreeBlock+0x15>
7730622c:	8b 58 0c             	mov    0xc(%eax),%ebx
7730622f:	8d 51 20             	lea    0x20(%ecx),%edx
77306232:	eb 0f                	jmp    77306243 <_HEAP_FindFreeBlock+0x33>
77306234:	8b 03                	mov    (%ebx),%eax
77306236:	83 e0 fc             	and    $0xfffffffc,%eax
77306239:	83 c0 08             	add    $0x8,%eax
7730623c:	39 f0                	cmp    %esi,%eax
7730623e:	73 4e                	jae    7730628e <_HEAP_FindFreeBlock+0x7e>
77306240:	8b 5b 08             	mov    0x8(%ebx),%ebx
77306243:	39 da                	cmp    %ebx,%edx
77306245:	75 ed                	jne    77306234 <_HEAP_FindFreeBlock+0x24>
77306247:	8b 91 84 00 00 00    	mov    0x84(%ecx),%edx
7730624d:	31 c0                	xor    %eax,%eax
7730624f:	f6 c2 02             	test   $0x2,%dl
77306252:	74 32                	je     77306286 <_HEAP_FindFreeBlock+0x76>
77306254:	83 c6 40             	add    $0x40,%esi
77306257:	89 f0                	mov    %esi,%eax
77306259:	53                   	push   %ebx
7730625a:	81 fe 00 00 11 00    	cmp    $0x110000,%esi
77306260:	73 05                	jae    77306267 <_HEAP_FindFreeBlock+0x57>
77306262:	b8 00 00 11 00       	mov    $0x110000,%eax
77306267:	50                   	push   %eax
77306268:	31 c0                	xor    %eax,%eax
7730626a:	56                   	push   %esi
7730626b:	52                   	push   %edx
7730626c:	89 ca                	mov    %ecx,%edx
7730626e:	e8 bd fd ff ff       	call   77306030 <_HEAP_CreateSubHeap>
77306273:	83 c4 10             	add    $0x10,%esp
77306276:	89 c7                	mov    %eax,%edi
77306278:	31 c0                	xor    %eax,%eax
7730627a:	85 ff                	test   %edi,%edi
7730627c:	74 08                	je     77306286 <_HEAP_FindFreeBlock+0x76>
7730627e:	8b 45 08             	mov    0x8(%ebp),%eax
77306281:	89 38                	mov    %edi,(%eax)
77306283:	8d 47 18             	lea    0x18(%edi),%eax
77306286:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77306289:	5b                   	pop    %ebx
7730628a:	5e                   	pop    %esi
7730628b:	5f                   	pop    %edi
7730628c:	5d                   	pop    %ebp
7730628d:	c3                   	ret    
7730628e:	89 da                	mov    %ebx,%edx
77306290:	89 c8                	mov    %ecx,%eax
77306292:	e8 39 fb ff ff       	call   77305dd0 <_HEAP_FindSubHeap>
77306297:	29 c6                	sub    %eax,%esi
77306299:	89 c7                	mov    %eax,%edi
7730629b:	8b 00                	mov    (%eax),%eax
7730629d:	8d 94 1e 1f 00 01 00 	lea    0x1001f(%esi,%ebx,1),%edx
773062a4:	81 e2 00 00 ff ff    	and    $0xffff0000,%edx
773062aa:	39 d0                	cmp    %edx,%eax
773062ac:	73 02                	jae    773062b0 <_HEAP_FindFreeBlock+0xa0>
773062ae:	89 c2                	mov    %eax,%edx
773062b0:	8b 4f 04             	mov    0x4(%edi),%ecx
773062b3:	be 01 00 00 00       	mov    $0x1,%esi
773062b8:	39 d1                	cmp    %edx,%ecx
773062ba:	72 15                	jb     773062d1 <_HEAP_FindFreeBlock+0xc1>
773062bc:	31 c0                	xor    %eax,%eax
773062be:	85 f6                	test   %esi,%esi
773062c0:	74 c4                	je     77306286 <_HEAP_FindFreeBlock+0x76>
773062c2:	8b 45 08             	mov    0x8(%ebp),%eax
773062c5:	89 38                	mov    %edi,(%eax)
773062c7:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773062ca:	89 d8                	mov    %ebx,%eax
773062cc:	5b                   	pop    %ebx
773062cd:	5e                   	pop    %esi
773062ce:	5f                   	pop    %edi
773062cf:	5d                   	pop    %ebp
773062d0:	c3                   	ret    
773062d1:	8d 04 39             	lea    (%ecx,%edi,1),%eax
773062d4:	29 ca                	sub    %ecx,%edx
773062d6:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
773062d9:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
773062dc:	66 31 f6             	xor    %si,%si
773062df:	89 55 f0             	mov    %edx,0xfffffff0(%ebp)
773062e2:	51                   	push   %ecx
773062e3:	51                   	push   %ecx
773062e4:	6a 40                	push   $0x40
773062e6:	68 00 10 00 00       	push   $0x1000
773062eb:	50                   	push   %eax
773062ec:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
773062ef:	6a 00                	push   $0x0
773062f1:	50                   	push   %eax
773062f2:	6a ff                	push   $0xffffffff
773062f4:	e8 17 17 00 00       	call   77307a10 <_NtAllocateVirtualMemory@24>
773062f9:	59                   	pop    %ecx
773062fa:	85 c0                	test   %eax,%eax
773062fc:	5a                   	pop    %edx
773062fd:	78 bd                	js     773062bc <_HEAP_FindFreeBlock+0xac>
773062ff:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
77306302:	8b 57 04             	mov    0x4(%edi),%edx
77306305:	01 c2                	add    %eax,%edx
77306307:	66 be 01 00          	mov    $0x1,%si
7730630b:	89 57 04             	mov    %edx,0x4(%edi)
7730630e:	eb ac                	jmp    773062bc <_HEAP_FindFreeBlock+0xac>

77306310 <_HEAP_IsValidArenaPtr>:
77306310:	55                   	push   %ebp
77306311:	89 e5                	mov    %esp,%ebp
77306313:	56                   	push   %esi
77306314:	89 d6                	mov    %edx,%esi
77306316:	53                   	push   %ebx
77306317:	89 c3                	mov    %eax,%ebx
77306319:	e8 b2 fa ff ff       	call   77305dd0 <_HEAP_FindSubHeap>
7730631e:	31 c9                	xor    %ecx,%ecx
77306320:	89 c2                	mov    %eax,%edx
77306322:	85 c0                	test   %eax,%eax
77306324:	74 11                	je     77306337 <_HEAP_IsValidArenaPtr+0x27>
77306326:	8b 40 08             	mov    0x8(%eax),%eax
77306329:	b1 01                	mov    $0x1,%cl
7730632b:	01 d0                	add    %edx,%eax
7730632d:	39 f0                	cmp    %esi,%eax
7730632f:	76 06                	jbe    77306337 <_HEAP_IsValidArenaPtr+0x27>
77306331:	30 c9                	xor    %cl,%cl
77306333:	39 da                	cmp    %ebx,%edx
77306335:	74 06                	je     7730633d <_HEAP_IsValidArenaPtr+0x2d>
77306337:	89 c8                	mov    %ecx,%eax
77306339:	5b                   	pop    %ebx
7730633a:	5e                   	pop    %esi
7730633b:	5d                   	pop    %ebp
7730633c:	c3                   	ret    
7730633d:	31 d2                	xor    %edx,%edx
7730633f:	8d 43 20             	lea    0x20(%ebx),%eax
77306342:	39 f0                	cmp    %esi,%eax
77306344:	74 0d                	je     77306353 <_HEAP_IsValidArenaPtr+0x43>
77306346:	42                   	inc    %edx
77306347:	83 c0 14             	add    $0x14,%eax
7730634a:	83 fa 03             	cmp    $0x3,%edx
7730634d:	7e f3                	jle    77306342 <_HEAP_IsValidArenaPtr+0x32>
7730634f:	31 c9                	xor    %ecx,%ecx
77306351:	eb e4                	jmp    77306337 <_HEAP_IsValidArenaPtr+0x27>
77306353:	b9 01 00 00 00       	mov    $0x1,%ecx
77306358:	eb dd                	jmp    77306337 <_HEAP_IsValidArenaPtr+0x27>
7730635a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

77306360 <_HEAP_ValidateInUseArena>:
   if ((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) > heapEnd)
   {
      DPRINT("Heap %p: bad size %08lx for free arena %p\n",
             subheap->heap, (ULONG)pArena->size & ARENA_SIZE_MASK, pArena );
      return FALSE;
   }
   /* Check that next pointer is valid */
   if (!HEAP_IsValidArenaPtr( subheap->heap, pArena->next ))
   {
      DPRINT("Heap %p: bad next ptr %p for arena %p\n",
             subheap->heap, pArena->next, pArena);
      return FALSE;
   }
   /* Check that next arena is free */
   if (!(pArena->next->size & ARENA_FLAG_FREE) ||
         (pArena->next->magic != ARENA_FREE_MAGIC))
   {
      DPRINT("Heap %p: next arena %p invalid for %p\n",
             subheap->heap, pArena->next, pArena);
      return FALSE;
   }
   /* Check that prev pointer is valid */
   if (!HEAP_IsValidArenaPtr( subheap->heap, pArena->prev ))
   {
      DPRINT("Heap %p: bad prev ptr %p for arena %p\n",
             subheap->heap, pArena->prev, pArena);
      return FALSE;
   }
   /* Check that prev arena is free */
   if (!(pArena->prev->size & ARENA_FLAG_FREE) ||
         (pArena->prev->magic != ARENA_FREE_MAGIC))
   {
      DPRINT("Heap %p: prev arena %p invalid for %p\n",
             subheap->heap, pArena->prev, pArena);
      return FALSE;
   }
   /* Check that next block has PREV_FREE flag */
   if ((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) < heapEnd)
   {
      if (!(*(PULONG)((char *)(pArena + 1) +
                       (pArena->size & ARENA_SIZE_MASK)) & ARENA_FLAG_PREV_FREE))
      {
         DPRINT("Heap %p: free arena %p next block has no PREV_FREE flag\n",
                subheap->heap, pArena);
         return FALSE;
      }
      /* Check next block back pointer */
      if (*((ARENA_FREE **)((char *)(pArena + 1) +
                            (pArena->size & ARENA_SIZE_MASK)) - 1) != pArena)
      {
         DPRINT("Heap %p: arena %p has wrong back ptr %p\n",
                subheap->heap, pArena,
                *((PULONG)((char *)(pArena+1)+ (pArena->size & ARENA_SIZE_MASK)) - 1));
         return FALSE;
      }
   }
   return TRUE;
}


/***********************************************************************
 *           HEAP_ValidateInUseArena
 */
static BOOLEAN HEAP_ValidateInUseArena( SUBHEAP *subheap, ARENA_INUSE *pArena, BOOLEAN quiet )
{
77306360:	55                   	push   %ebp
77306361:	89 c1                	mov    %eax,%ecx
77306363:	89 e5                	mov    %esp,%ebp
77306365:	57                   	push   %edi
77306366:	56                   	push   %esi
77306367:	53                   	push   %ebx
77306368:	56                   	push   %esi
   char *heapEnd = (char *)subheap + subheap->size;
77306369:	8b 30                	mov    (%eax),%esi
7730636b:	89 d3                	mov    %edx,%ebx
7730636d:	01 c6                	add    %eax,%esi

   /* Check magic number */
   if (pArena->magic != ARENA_INUSE_MAGIC)
   {
      if (quiet == NOISY)
      {
         DPRINT("Heap %p: invalid in-use arena magic for %p\n",
                subheap->heap, pArena);
         if (TRACE_ON(heap))
            HEAP_Dump( subheap->heap );
      }
      else if (WARN_ON(heap))
      {
         DPRINT("Heap %p: invalid in-use arena magic for %p\n",
                subheap->heap, pArena);
         if (TRACE_ON(heap))
            HEAP_Dump( subheap->heap );
      }
      return FALSE;
7730636f:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
77306376:	66 81 7a 06 42 48    	cmpw   $0x4842,0x6(%edx)
7730637c:	74 09                	je     77306387 <_HEAP_ValidateInUseArena+0x27>
   }
   /* Check size flags */
   if (pArena->size & ARENA_FLAG_FREE)
   {
      DPRINT("Heap %p: bad flags %lx for in-use arena %p\n",
             subheap->heap, pArena->size & ~ARENA_SIZE_MASK, pArena);
      return FALSE;
   }
   /* Check arena size */
   if ((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) > heapEnd)
   {
      DPRINT("Heap %p: bad size %08lx for in-use arena %p\n",
             subheap->heap, (ULONG)pArena->size & ARENA_SIZE_MASK, pArena);
      return FALSE;
   }
   /* Check next arena PREV_FREE flag */
   if (((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK) < heapEnd) &&
         (*(PULONG)((char *)(pArena + 1) + (pArena->size & ARENA_SIZE_MASK)) & ARENA_FLAG_PREV_FREE))
   {
      DPRINT("Heap %p: in-use arena %p next block has PREV_FREE flag\n",
             subheap->heap, pArena);
      return FALSE;
   }
   /* Check prev free arena */
   if (pArena->size & ARENA_FLAG_PREV_FREE)
   {
      ARENA_FREE *pPrev = *((ARENA_FREE **)pArena - 1);
      /* Check prev pointer */
      if (!HEAP_IsValidArenaPtr( subheap->heap, pPrev ))
      {
         DPRINT("Heap %p: bad back ptr %p for arena %p\n",
                subheap->heap, pPrev, pArena );
         return FALSE;
      }
      /* Check that prev arena is free */
      if (!(pPrev->size & ARENA_FLAG_FREE) ||
            (pPrev->magic != ARENA_FREE_MAGIC))
      {
         DPRINT("Heap %p: prev arena %p invalid for in-use %p\n",
                subheap->heap, pPrev, pArena);
         return FALSE;
      }
      /* Check that prev arena is really the previous block */
      if ((char *)(pPrev + 1) + (pPrev->size & ARENA_SIZE_MASK) != (char *)pArena)
      {
         DPRINT("Heap %p: prev arena %p is not prev for in-use %p\n",
                subheap->heap, pPrev, pArena );
         return FALSE;
      }
   }
   return TRUE;
}
7730637e:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
77306381:	5b                   	pop    %ebx
77306382:	5b                   	pop    %ebx
77306383:	5e                   	pop    %esi
77306384:	5f                   	pop    %edi
77306385:	5d                   	pop    %ebp
77306386:	c3                   	ret    
77306387:	8b 12                	mov    (%edx),%edx
77306389:	f6 c2 01             	test   $0x1,%dl
7730638c:	75 f0                	jne    7730637e <_HEAP_ValidateInUseArena+0x1e>
7730638e:	89 d7                	mov    %edx,%edi
77306390:	83 e7 fc             	and    $0xfffffffc,%edi
77306393:	8d 44 1f 08          	lea    0x8(%edi,%ebx,1),%eax
77306397:	39 f0                	cmp    %esi,%eax
77306399:	77 e3                	ja     7730637e <_HEAP_ValidateInUseArena+0x1e>
7730639b:	72 0e                	jb     773063ab <_HEAP_ValidateInUseArena+0x4b>
7730639d:	83 e2 02             	and    $0x2,%edx
773063a0:	75 12                	jne    773063b4 <_HEAP_ValidateInUseArena+0x54>
773063a2:	c7 45 f0 01 00 00 00 	movl   $0x1,0xfffffff0(%ebp)
773063a9:	eb d3                	jmp    7730637e <_HEAP_ValidateInUseArena+0x1e>
773063ab:	f6 44 1f 08 02       	testb  $0x2,0x8(%edi,%ebx,1)
773063b0:	75 cc                	jne    7730637e <_HEAP_ValidateInUseArena+0x1e>
773063b2:	eb e9                	jmp    7730639d <_HEAP_ValidateInUseArena+0x3d>
773063b4:	8b 73 fc             	mov    0xfffffffc(%ebx),%esi
773063b7:	8b 41 10             	mov    0x10(%ecx),%eax
773063ba:	89 f2                	mov    %esi,%edx
773063bc:	e8 4f ff ff ff       	call   77306310 <_HEAP_IsValidArenaPtr>
773063c1:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
773063c8:	84 c0                	test   %al,%al
773063ca:	74 b2                	je     7730637e <_HEAP_ValidateInUseArena+0x1e>
773063cc:	8b 06                	mov    (%esi),%eax
773063ce:	a8 01                	test   $0x1,%al
773063d0:	74 08                	je     773063da <_HEAP_ValidateInUseArena+0x7a>
773063d2:	66 81 7e 06 46 48    	cmpw   $0x4846,0x6(%esi)
773063d8:	74 09                	je     773063e3 <_HEAP_ValidateInUseArena+0x83>
773063da:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
773063e1:	eb 9b                	jmp    7730637e <_HEAP_ValidateInUseArena+0x1e>
773063e3:	83 e0 fc             	and    $0xfffffffc,%eax
773063e6:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
773063ed:	8d 44 30 10          	lea    0x10(%eax,%esi,1),%eax
773063f1:	39 d8                	cmp    %ebx,%eax
773063f3:	75 89                	jne    7730637e <_HEAP_ValidateInUseArena+0x1e>
773063f5:	eb ab                	jmp    773063a2 <_HEAP_ValidateInUseArena+0x42>
773063f7:	89 f6                	mov    %esi,%esi
773063f9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77306400 <_HEAP_IsInsideHeap>:


/***********************************************************************
 *           HEAP_IsInsideHeap
 * Checks whether the pointer points to a block inside a given heap.
 *
 * NOTES
 * Should this return BOOL32?
 *
 * RETURNS
 * !0: Success
 * 0: Failure
 */
int HEAP_IsInsideHeap(
   HANDLE heap, /* [in] Heap */
   ULONG flags,   /* [in] Flags */
   PVOID ptr    /* [in] Pointer */
)
{
77306400:	55                   	push   %ebp
77306401:	89 e5                	mov    %esp,%ebp
77306403:	57                   	push   %edi
77306404:	56                   	push   %esi
77306405:	53                   	push   %ebx
77306406:	83 ec 0c             	sub    $0xc,%esp
77306409:	8b 45 08             	mov    0x8(%ebp),%eax
7730640c:	8b 75 0c             	mov    0xc(%ebp),%esi
   HEAP *heapPtr = HEAP_GetPtr( heap );
7730640f:	e8 9c f9 ff ff       	call   77305db0 <_HEAP_GetPtr>
77306414:	8b 7d 10             	mov    0x10(%ebp),%edi
77306417:	89 c3                	mov    %eax,%ebx
   SUBHEAP *subheap;
   int ret;

   /* Validate the parameters */

   if (!heapPtr)
      return 0;
77306419:	31 c0                	xor    %eax,%eax
7730641b:	85 db                	test   %ebx,%ebx
7730641d:	74 3f                	je     7730645e <_HEAP_IsInsideHeap+0x5e>
   flags |= heapPtr->flags;
7730641f:	8b 8b 84 00 00 00    	mov    0x84(%ebx),%ecx
77306425:	09 ce                	or     %ecx,%esi
   if (!(flags & HEAP_NO_SERIALIZE))
77306427:	f7 c6 01 00 00 00    	test   $0x1,%esi
7730642d:	74 48                	je     77306477 <_HEAP_IsInsideHeap+0x77>
      RtlEnterCriticalSection( &heapPtr->critSection );
   ret = (((subheap = HEAP_FindSubHeap( heapPtr, ptr )) != NULL) &&
7730642f:	89 fa                	mov    %edi,%edx
77306431:	89 d8                	mov    %ebx,%eax
77306433:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
7730643a:	e8 91 f9 ff ff       	call   77305dd0 <_HEAP_FindSubHeap>
7730643f:	85 c0                	test   %eax,%eax
77306441:	74 13                	je     77306456 <_HEAP_IsInsideHeap+0x56>
77306443:	8b 50 08             	mov    0x8(%eax),%edx
77306446:	01 d0                	add    %edx,%eax
77306448:	83 c0 08             	add    $0x8,%eax
7730644b:	39 f8                	cmp    %edi,%eax
7730644d:	77 07                	ja     77306456 <_HEAP_IsInsideHeap+0x56>
7730644f:	c7 45 f0 01 00 00 00 	movl   $0x1,0xfffffff0(%ebp)
          (((char *)ptr >= (char *)subheap + subheap->headerSize
            + sizeof(ARENA_INUSE))));
   if (!(flags & HEAP_NO_SERIALIZE))
77306456:	83 e6 01             	and    $0x1,%esi
77306459:	74 0b                	je     77306466 <_HEAP_IsInsideHeap+0x66>
      RtlLeaveCriticalSection( &heapPtr->critSection );
   return ret;
7730645b:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
}
7730645e:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77306461:	5b                   	pop    %ebx
77306462:	5e                   	pop    %esi
77306463:	5f                   	pop    %edi
77306464:	5d                   	pop    %ebp
77306465:	c3                   	ret    
77306466:	83 ec 0c             	sub    $0xc,%esp
77306469:	8d 43 6c             	lea    0x6c(%ebx),%eax
7730646c:	50                   	push   %eax
7730646d:	e8 ae 15 00 00       	call   77307a20 <_RtlLeaveCriticalSection@4>
77306472:	83 c4 0c             	add    $0xc,%esp
77306475:	eb e4                	jmp    7730645b <_HEAP_IsInsideHeap+0x5b>
77306477:	83 ec 0c             	sub    $0xc,%esp
7730647a:	8d 43 6c             	lea    0x6c(%ebx),%eax
7730647d:	50                   	push   %eax
7730647e:	e8 ad 15 00 00       	call   77307a30 <_RtlEnterCriticalSection@4>
77306483:	83 c4 0c             	add    $0xc,%esp
77306486:	eb a7                	jmp    7730642f <_HEAP_IsInsideHeap+0x2f>
77306488:	90                   	nop    
77306489:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

77306490 <_DumpStackFrames>:


void DumpStackFrames ( PULONG Frame, ULONG FrameCount )
{
77306490:	55                   	push   %ebp
77306491:	89 e5                	mov    %esp,%ebp
77306493:	57                   	push   %edi
77306494:	56                   	push   %esi
77306495:	53                   	push   %ebx
77306496:	83 ec 18             	sub    $0x18,%esp
	ULONG i=0;
77306499:	31 f6                	xor    %esi,%esi
7730649b:	8b 5d 08             	mov    0x8(%ebp),%ebx
7730649e:	8b 7d 0c             	mov    0xc(%ebp),%edi

	DbgPrint("Frames: ");
773064a1:	68 40 ab 30 77       	push   $0x7730ab40
773064a6:	e8 d5 14 00 00       	call   77307980 <_DbgPrint>
	if ( !Frame )
773064ab:	83 c4 10             	add    $0x10,%esp
773064ae:	85 db                	test   %ebx,%ebx
773064b0:	75 52                	jne    77306504 <_DumpStackFrames+0x74>
773064b2:	eb 7a                	jmp    7730652e <_DumpStackFrames+0x9e>
	{
#if defined __GNUC__
		__asm__("mov %%ebp, %%ebx" : "=b" (Frame) : );
#elif defined(_MSC_VER)
		__asm mov [Frame], ebp
#endif
		Frame = (PULONG)Frame[0]; // step out of DumpStackFrames
	}
	while ( Frame != 0 && (ULONG)Frame != 0xDEADBEEF && (ULONG)Frame != 0xcdcdcdcd && (ULONG)Frame != 0xcccccccc && i++ < FrameCount )
	{
		DbgPrint("<%X>", (PVOID)Frame[1]);
		if (Frame[1] == 0xdeadbeef)
		    break;
		Frame = (PULONG)Frame[0];
		DbgPrint(" ");
773064b4:	81 fb cd cd cd cd    	cmp    $0xcdcdcdcd,%ebx
773064ba:	0f 95 c2             	setne  %dl
773064bd:	81 fb cc cc cc cc    	cmp    $0xcccccccc,%ebx
773064c3:	0f 95 c0             	setne  %al
773064c6:	25 ff 00 00 00       	and    $0xff,%eax
773064cb:	85 c2                	test   %eax,%edx
773064cd:	74 4c                	je     7730651b <_DumpStackFrames+0x8b>
773064cf:	89 f0                	mov    %esi,%eax
773064d1:	46                   	inc    %esi
773064d2:	39 f8                	cmp    %edi,%eax
773064d4:	73 45                	jae    7730651b <_DumpStackFrames+0x8b>
773064d6:	50                   	push   %eax
773064d7:	50                   	push   %eax
773064d8:	8b 43 04             	mov    0x4(%ebx),%eax
773064db:	50                   	push   %eax
773064dc:	68 49 ab 30 77       	push   $0x7730ab49
773064e1:	e8 9a 14 00 00       	call   77307980 <_DbgPrint>
773064e6:	83 c4 10             	add    $0x10,%esp
773064e9:	81 7b 04 ef be ad de 	cmpl   $0xdeadbeef,0x4(%ebx)
773064f0:	74 29                	je     7730651b <_DumpStackFrames+0x8b>
773064f2:	83 ec 0c             	sub    $0xc,%esp
773064f5:	8b 1b                	mov    (%ebx),%ebx
773064f7:	68 4e ab 30 77       	push   $0x7730ab4e
773064fc:	e8 7f 14 00 00       	call   77307980 <_DbgPrint>
77306501:	83 c4 10             	add    $0x10,%esp
77306504:	85 db                	test   %ebx,%ebx
77306506:	0f 95 c2             	setne  %dl
77306509:	81 fb ef be ad de    	cmp    $0xdeadbeef,%ebx
7730650f:	0f 95 c0             	setne  %al
77306512:	25 ff 00 00 00       	and    $0xff,%eax
77306517:	85 c2                	test   %eax,%edx
77306519:	75 99                	jne    773064b4 <_DumpStackFrames+0x24>
	}
	DbgPrint("\n");
7730651b:	c7 45 08 50 ab 30 77 	movl   $0x7730ab50,0x8(%ebp)
77306522:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77306525:	5b                   	pop    %ebx
77306526:	5e                   	pop    %esi
77306527:	5f                   	pop    %edi
77306528:	5d                   	pop    %ebp
77306529:	e9 52 14 00 00       	jmp    77307980 <_DbgPrint>
7730652e:	89 eb                	mov    %ebp,%ebx
77306530:	8b 1b                	mov    (%ebx),%ebx
77306532:	eb d0                	jmp    77306504 <_DumpStackFrames+0x74>
77306534:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
7730653a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

77306540 <_HEAP_IsRealArena>:
}

/***********************************************************************
 *           HEAP_IsRealArena  [Internal]
 * Validates a block is a valid arena.
 *
 * RETURNS
 * TRUE: Success
 * FALSE: Failure
 */
static BOOLEAN HEAP_IsRealArena(
   HANDLE heap,   /* [in] Handle to the heap */
   ULONG flags,   /* [in] Bit flags that control access during operation */
   PVOID block,   /* [in] Optional pointer to memory block to validate */
   BOOLEAN quiet  /* [in] Flag - if true, HEAP_ValidateInUseArena
                   *             does not complain    */
)
{
77306540:	55                   	push   %ebp
77306541:	89 e5                	mov    %esp,%ebp
77306543:	57                   	push   %edi
77306544:	56                   	push   %esi
77306545:	53                   	push   %ebx
77306546:	83 ec 0c             	sub    $0xc,%esp
77306549:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
7730654c:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
7730654f:	8b 5d 08             	mov    0x8(%ebp),%ebx
77306552:	0f b6 7d 0c          	movzbl 0xc(%ebp),%edi
   SUBHEAP *subheap;
   HEAP *heapPtr = (HEAP *)(heap);
   BOOLEAN ret = TRUE;
77306556:	c6 45 eb 01          	movb   $0x1,0xffffffeb(%ebp)

   if (!heapPtr || (heapPtr->magic != HEAP_MAGIC))
7730655a:	85 c0                	test   %eax,%eax
7730655c:	74 0c                	je     7730656a <_HEAP_IsRealArena+0x2a>
7730655e:	81 b8 88 00 00 00 48 	cmpl   $0x50414548,0x88(%eax)
77306565:	45 41 50 
77306568:	74 0a                	je     77306574 <_HEAP_IsRealArena+0x34>
   {
      DPRINT("Invalid heap %08x!\n", heap );
      return FALSE;
   }

   flags &= HEAP_NO_SERIALIZE;
   flags |= heapPtr->flags;
   /* calling HeapLock may result in infinite recursion, so do the critsect directly */
   if (!(flags & HEAP_NO_SERIALIZE))
      RtlEnterCriticalSection( &heapPtr->critSection );

   if (block)
   {
      /* Only check this single memory block */

      /* The following code is really HEAP_IsInsideHeap   *
       * with serialization already done.                 */
      if (!(subheap = HEAP_FindSubHeap( heapPtr, block )) ||
            ((char *)block < (char *)subheap + subheap->headerSize
             + sizeof(ARENA_INUSE)))
      {
         if (quiet == NOISY)
         {
            DPRINT("Heap %p: block %p is not inside heap\n",
                   heap, block );
			DumpStackFrames(NULL,10);
         }
         else if (WARN_ON(heap))
         {
            DPRINT1("Heap %p: block %p is not inside heap\n",
                    heap, block );
			DumpStackFrames(NULL,10);
         }
         ret = FALSE;
      }
      else
         ret = HEAP_ValidateInUseArena( subheap, (ARENA_INUSE *)block - 1, quiet );

      if (!(flags & HEAP_NO_SERIALIZE))
         RtlLeaveCriticalSection( &heapPtr->critSection );
      return ret;
   }

   subheap = &heapPtr->subheap;
   while (subheap && ret)
   {
      char *ptr = (char *)subheap + subheap->headerSize;
      while (ptr < (char *)subheap + subheap->size)
      {
         if (*(PULONG)ptr & ARENA_FLAG_FREE)
         {
            if (!HEAP_ValidateFreeArena( subheap, (ARENA_FREE *)ptr ))
            {
               ret = FALSE;
               break;
            }
            ptr += sizeof(ARENA_FREE) + (*(PULONG)ptr & ARENA_SIZE_MASK);
         }
         else
         {
            if (!HEAP_ValidateInUseArena( subheap, (ARENA_INUSE *)ptr, NOISY ))
            {
               ret = FALSE;
               break;
            }
            ptr += sizeof(ARENA_INUSE) + (*(PULONG)ptr & ARENA_SIZE_MASK);
         }
      }
      subheap = subheap->next;
   }

   if (!(flags & HEAP_NO_SERIALIZE))
      RtlLeaveCriticalSection( &heapPtr->critSection );
   return ret;
}
7730656a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
7730656d:	31 c0                	xor    %eax,%eax
7730656f:	5b                   	pop    %ebx
77306570:	5e                   	pop    %esi
77306571:	5f                   	pop    %edi
77306572:	5d                   	pop    %ebp
77306573:	c3                   	ret    
77306574:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
77306577:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
7730657a:	83 e1 01             	and    $0x1,%ecx
7730657d:	89 4d ec             	mov    %ecx,0xffffffec(%ebp)
77306580:	8b 80 84 00 00 00    	mov    0x84(%eax),%eax
77306586:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
77306589:	09 c2                	or     %eax,%edx
7730658b:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
7730658e:	f6 45 ec 01          	testb  $0x1,0xffffffec(%ebp)
77306592:	74 6c                	je     77306600 <_HEAP_IsRealArena+0xc0>
77306594:	85 db                	test   %ebx,%ebx
77306596:	74 7c                	je     77306614 <_HEAP_IsRealArena+0xd4>
77306598:	89 da                	mov    %ebx,%edx
7730659a:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
7730659d:	e8 2e f8 ff ff       	call   77305dd0 <_HEAP_FindSubHeap>
773065a2:	89 c6                	mov    %eax,%esi
773065a4:	85 c0                	test   %eax,%eax
773065a6:	74 10                	je     773065b8 <_HEAP_IsRealArena+0x78>
773065a8:	8b 40 08             	mov    0x8(%eax),%eax
773065ab:	01 f0                	add    %esi,%eax
773065ad:	83 c0 08             	add    $0x8,%eax
773065b0:	39 d8                	cmp    %ebx,%eax
773065b2:	0f 86 b1 01 00 00    	jbe    77306769 <_HEAP_IsRealArena+0x229>
773065b8:	89 f8                	mov    %edi,%eax
773065ba:	84 c0                	test   %al,%al
773065bc:	0f 85 01 01 00 00    	jne    773066c3 <_HEAP_IsRealArena+0x183>
773065c2:	50                   	push   %eax
773065c3:	50                   	push   %eax
773065c4:	6a 0a                	push   $0xa
773065c6:	6a 00                	push   $0x0
773065c8:	e8 c3 fe ff ff       	call   77306490 <_DumpStackFrames>
773065cd:	83 c4 10             	add    $0x10,%esp
773065d0:	c6 45 eb 00          	movb   $0x0,0xffffffeb(%ebp)
773065d4:	f6 45 ec 01          	testb  $0x1,0xffffffec(%ebp)
773065d8:	74 0d                	je     773065e7 <_HEAP_IsRealArena+0xa7>
773065da:	31 c0                	xor    %eax,%eax
773065dc:	8a 45 eb             	mov    0xffffffeb(%ebp),%al
773065df:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773065e2:	5b                   	pop    %ebx
773065e3:	5e                   	pop    %esi
773065e4:	5f                   	pop    %edi
773065e5:	5d                   	pop    %ebp
773065e6:	c3                   	ret    
773065e7:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
773065ea:	83 ec 0c             	sub    $0xc,%esp
773065ed:	83 c0 6c             	add    $0x6c,%eax
773065f0:	50                   	push   %eax
773065f1:	e8 2a 14 00 00       	call   77307a20 <_RtlLeaveCriticalSection@4>
773065f6:	31 c0                	xor    %eax,%eax
773065f8:	83 c4 0c             	add    $0xc,%esp
773065fb:	8a 45 eb             	mov    0xffffffeb(%ebp),%al
773065fe:	eb df                	jmp    773065df <_HEAP_IsRealArena+0x9f>
77306600:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
77306603:	83 ec 0c             	sub    $0xc,%esp
77306606:	83 c0 6c             	add    $0x6c,%eax
77306609:	50                   	push   %eax
7730660a:	e8 21 14 00 00       	call   77307a30 <_RtlEnterCriticalSection@4>
7730660f:	83 c4 0c             	add    $0xc,%esp
77306612:	eb 80                	jmp    77306594 <_HEAP_IsRealArena+0x54>
77306614:	8b 75 f0             	mov    0xfffffff0(%ebp),%esi
77306617:	8b 5e 08             	mov    0x8(%esi),%ebx
7730661a:	01 f3                	add    %esi,%ebx
7730661c:	8b 3e                	mov    (%esi),%edi
7730661e:	01 f7                	add    %esi,%edi
77306620:	39 df                	cmp    %ebx,%edi
77306622:	76 29                	jbe    7730664d <_HEAP_IsRealArena+0x10d>
77306624:	8b 03                	mov    (%ebx),%eax
77306626:	a8 01                	test   $0x1,%al
77306628:	74 46                	je     77306670 <_HEAP_IsRealArena+0x130>
7730662a:	31 d2                	xor    %edx,%edx
7730662c:	66 81 7b 06 46 48    	cmpw   $0x4846,0x6(%ebx)
77306632:	74 5c                	je     77306690 <_HEAP_IsRealArena+0x150>
77306634:	85 d2                	test   %edx,%edx
77306636:	0f 84 08 01 00 00    	je     77306744 <_HEAP_IsRealArena+0x204>
7730663c:	8b 03                	mov    (%ebx),%eax
7730663e:	8b 3e                	mov    (%esi),%edi
77306640:	83 e0 fc             	and    $0xfffffffc,%eax
77306643:	01 f7                	add    %esi,%edi
77306645:	8d 5c 18 10          	lea    0x10(%eax,%ebx,1),%ebx
77306649:	39 df                	cmp    %ebx,%edi
7730664b:	77 d7                	ja     77306624 <_HEAP_IsRealArena+0xe4>
7730664d:	8b 76 0c             	mov    0xc(%esi),%esi
77306650:	85 f6                	test   %esi,%esi
77306652:	0f 95 c2             	setne  %dl
77306655:	80 7d eb 00          	cmpb   $0x0,0xffffffeb(%ebp)
77306659:	0f 95 c0             	setne  %al
7730665c:	25 ff 00 00 00       	and    $0xff,%eax
77306661:	85 c2                	test   %eax,%edx
77306663:	75 b2                	jne    77306617 <_HEAP_IsRealArena+0xd7>
77306665:	e9 6a ff ff ff       	jmp    773065d4 <_HEAP_IsRealArena+0x94>
7730666a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77306670:	89 da                	mov    %ebx,%edx
77306672:	89 f0                	mov    %esi,%eax
77306674:	6a 00                	push   $0x0
77306676:	e8 e5 fc ff ff       	call   77306360 <_HEAP_ValidateInUseArena>
7730667b:	5a                   	pop    %edx
7730667c:	84 c0                	test   %al,%al
7730667e:	0f 84 c0 00 00 00    	je     77306744 <_HEAP_IsRealArena+0x204>
77306684:	8b 03                	mov    (%ebx),%eax
77306686:	83 e0 fc             	and    $0xfffffffc,%eax
77306689:	8d 5c 18 08          	lea    0x8(%eax,%ebx,1),%ebx
7730668d:	eb 8d                	jmp    7730661c <_HEAP_IsRealArena+0xdc>
7730668f:	90                   	nop    
77306690:	83 e0 fc             	and    $0xfffffffc,%eax
77306693:	8d 44 18 10          	lea    0x10(%eax,%ebx,1),%eax
77306697:	39 f8                	cmp    %edi,%eax
77306699:	77 99                	ja     77306634 <_HEAP_IsRealArena+0xf4>
7730669b:	8b 53 08             	mov    0x8(%ebx),%edx
7730669e:	8b 46 10             	mov    0x10(%esi),%eax
773066a1:	e8 6a fc ff ff       	call   77306310 <_HEAP_IsValidArenaPtr>
773066a6:	31 d2                	xor    %edx,%edx
773066a8:	84 c0                	test   %al,%al
773066aa:	74 88                	je     77306634 <_HEAP_IsRealArena+0xf4>
773066ac:	8b 43 08             	mov    0x8(%ebx),%eax
773066af:	f6 00 01             	testb  $0x1,(%eax)
773066b2:	74 08                	je     773066bc <_HEAP_IsRealArena+0x17c>
773066b4:	66 81 78 06 46 48    	cmpw   $0x4846,0x6(%eax)
773066ba:	74 35                	je     773066f1 <_HEAP_IsRealArena+0x1b1>
773066bc:	31 d2                	xor    %edx,%edx
773066be:	e9 71 ff ff ff       	jmp    77306634 <_HEAP_IsRealArena+0xf4>
773066c3:	50                   	push   %eax
773066c4:	68 ec 03 00 00       	push   $0x3ec
773066c9:	68 52 ab 30 77       	push   $0x7730ab52
773066ce:	68 59 ab 30 77       	push   $0x7730ab59
773066d3:	e8 a8 12 00 00       	call   77307980 <_DbgPrint>
773066d8:	83 c4 0c             	add    $0xc,%esp
773066db:	53                   	push   %ebx
773066dc:	8b 7d f0             	mov    0xfffffff0(%ebp),%edi
773066df:	57                   	push   %edi
773066e0:	68 64 ab 30 77       	push   $0x7730ab64
773066e5:	e8 96 12 00 00       	call   77307980 <_DbgPrint>
773066ea:	5b                   	pop    %ebx
773066eb:	5e                   	pop    %esi
773066ec:	e9 d3 fe ff ff       	jmp    773065c4 <_HEAP_IsRealArena+0x84>
773066f1:	8b 53 0c             	mov    0xc(%ebx),%edx
773066f4:	8b 46 10             	mov    0x10(%esi),%eax
773066f7:	e8 14 fc ff ff       	call   77306310 <_HEAP_IsValidArenaPtr>
773066fc:	31 d2                	xor    %edx,%edx
773066fe:	84 c0                	test   %al,%al
77306700:	0f 84 2e ff ff ff    	je     77306634 <_HEAP_IsRealArena+0xf4>
77306706:	8b 43 0c             	mov    0xc(%ebx),%eax
77306709:	f6 00 01             	testb  $0x1,(%eax)
7730670c:	74 ae                	je     773066bc <_HEAP_IsRealArena+0x17c>
7730670e:	66 81 78 06 46 48    	cmpw   $0x4846,0x6(%eax)
77306714:	75 a6                	jne    773066bc <_HEAP_IsRealArena+0x17c>
77306716:	8b 0b                	mov    (%ebx),%ecx
77306718:	83 e1 fc             	and    $0xfffffffc,%ecx
7730671b:	8d 44 19 10          	lea    0x10(%ecx,%ebx,1),%eax
7730671f:	39 f8                	cmp    %edi,%eax
77306721:	73 17                	jae    7730673a <_HEAP_IsRealArena+0x1fa>
77306723:	31 d2                	xor    %edx,%edx
77306725:	f6 44 19 10 02       	testb  $0x2,0x10(%ecx,%ebx,1)
7730672a:	0f 84 04 ff ff ff    	je     77306634 <_HEAP_IsRealArena+0xf4>
77306730:	39 5c 19 0c          	cmp    %ebx,0xc(%ecx,%ebx,1)
77306734:	0f 85 fa fe ff ff    	jne    77306634 <_HEAP_IsRealArena+0xf4>
7730673a:	ba 01 00 00 00       	mov    $0x1,%edx
7730673f:	e9 f0 fe ff ff       	jmp    77306634 <_HEAP_IsRealArena+0xf4>
77306744:	c6 45 eb 00          	movb   $0x0,0xffffffeb(%ebp)
77306748:	8b 76 0c             	mov    0xc(%esi),%esi
7730674b:	85 f6                	test   %esi,%esi
7730674d:	0f 95 c2             	setne  %dl
77306750:	80 7d eb 00          	cmpb   $0x0,0xffffffeb(%ebp)
77306754:	0f 95 c0             	setne  %al
77306757:	25 ff 00 00 00       	and    $0xff,%eax
7730675c:	85 c2                	test   %eax,%edx
7730675e:	0f 85 b3 fe ff ff    	jne    77306617 <_HEAP_IsRealArena+0xd7>
77306764:	e9 6b fe ff ff       	jmp    773065d4 <_HEAP_IsRealArena+0x94>
77306769:	89 f8                	mov    %edi,%eax
7730676b:	8d 53 f8             	lea    0xfffffff8(%ebx),%edx
7730676e:	25 ff 00 00 00       	and    $0xff,%eax
77306773:	50                   	push   %eax
77306774:	89 f0                	mov    %esi,%eax
77306776:	e8 e5 fb ff ff       	call   77306360 <_HEAP_ValidateInUseArena>
7730677b:	88 45 eb             	mov    %al,0xffffffeb(%ebp)
7730677e:	59                   	pop    %ecx
7730677f:	e9 50 fe ff ff       	jmp    773065d4 <_HEAP_IsRealArena+0x94>
77306784:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
7730678a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

77306790 <_RtlCreateHeap@24>:


/***********************************************************************
 *           HeapCreate   (KERNEL32.336)
 * RETURNS
 * Handle of heap: Success
 * NULL: Failure
 *
 * @implemented
 */
HANDLE STDCALL
RtlCreateHeap(ULONG flags,
              PVOID BaseAddress,
              ULONG maxSize,
              ULONG initialSize,
              PVOID Unknown,
              PRTL_HEAP_DEFINITION Definition)
{
77306790:	55                   	push   %ebp
77306791:	89 e5                	mov    %esp,%ebp
77306793:	53                   	push   %ebx
77306794:	50                   	push   %eax
77306795:	8b 55 10             	mov    0x10(%ebp),%edx
77306798:	8b 4d 08             	mov    0x8(%ebp),%ecx
7730679b:	8b 45 0c             	mov    0xc(%ebp),%eax
   SUBHEAP *subheap;
   HEAP *heapPtr;

   /* Allocate the heap block */

   if (!maxSize)
7730679e:	85 d2                	test   %edx,%edx
773067a0:	75 08                	jne    773067aa <_RtlCreateHeap@24+0x1a>
   {
      maxSize = HEAP_DEF_SIZE;
773067a2:	ba 00 00 11 00       	mov    $0x110000,%edx
      flags |= HEAP_GROWABLE;
773067a7:	83 c9 02             	or     $0x2,%ecx
   }
   if (!(subheap = HEAP_CreateSubHeap( BaseAddress, NULL, flags, initialSize, maxSize )))
773067aa:	53                   	push   %ebx
773067ab:	8b 5d 14             	mov    0x14(%ebp),%ebx
773067ae:	52                   	push   %edx
773067af:	31 d2                	xor    %edx,%edx
773067b1:	53                   	push   %ebx
773067b2:	51                   	push   %ecx
773067b3:	e8 78 f8 ff ff       	call   77306030 <_HEAP_CreateSubHeap>
773067b8:	89 c3                	mov    %eax,%ebx
773067ba:	83 c4 10             	add    $0x10,%esp
   {
      return 0;
773067bd:	31 c0                	xor    %eax,%eax
773067bf:	85 db                	test   %ebx,%ebx
773067c1:	74 4a                	je     7730680d <_RtlCreateHeap@24+0x7d>
   }

   /* link it into the per-process heap list */
   RtlEnterCriticalSection (&RtlpProcessHeapsListLock);
773067c3:	83 ec 0c             	sub    $0xc,%esp
773067c6:	68 50 c0 30 77       	push   $0x7730c050
773067cb:	e8 60 12 00 00       	call   77307a30 <_RtlEnterCriticalSection@4>
   
   heapPtr = subheap->heap;
773067d0:	8b 53 10             	mov    0x10(%ebx),%edx
 struct _PEB * pPeb;

#if defined(__GNUC__)

 __asm__ __volatile__
773067d3:	64 a1 30 00 00 00    	mov    %fs:0x30,%eax
773067d9:	8b 80 90 00 00 00    	mov    0x90(%eax),%eax
773067df:	89 42 18             	mov    %eax,0x18(%edx)
773067e2:	64 a1 30 00 00 00    	mov    %fs:0x30,%eax
773067e8:	89 90 90 00 00 00    	mov    %edx,0x90(%eax)
773067ee:	64 a1 30 00 00 00    	mov    %fs:0x30,%eax
773067f4:	8b 90 88 00 00 00    	mov    0x88(%eax),%edx
773067fa:	42                   	inc    %edx
773067fb:	89 90 88 00 00 00    	mov    %edx,0x88(%eax)
   heapPtr->next = (HEAP*)NtCurrentPeb()->ProcessHeaps;
   NtCurrentPeb()->ProcessHeaps = (HANDLE)heapPtr;
   NtCurrentPeb()->NumberOfHeaps++;
   
   RtlLeaveCriticalSection (&RtlpProcessHeapsListLock);
77306801:	68 50 c0 30 77       	push   $0x7730c050
77306806:	e8 15 12 00 00       	call   77307a20 <_RtlLeaveCriticalSection@4>

   return (HANDLE)subheap;
7730680b:	89 d8                	mov    %ebx,%eax
}
7730680d:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
77306810:	c9                   	leave  
77306811:	c2 18 00             	ret    $0x18
77306814:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
7730681a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

77306820 <_RtlDestroyHeap@4>:

/***********************************************************************
 *           HeapDestroy   (KERNEL32.337)
 * RETURNS
 * TRUE: Success
 * FALSE: Failure
 *
 * @implemented
 * 
 * RETURNS
 *  Success: A NULL HANDLE, if heap is NULL or it was destroyed
 *  Failure: The Heap handle, if heap is the process heap.
 */
HANDLE STDCALL
RtlDestroyHeap(HANDLE heap) /* [in] Handle of heap */
{
77306820:	55                   	push   %ebp
77306821:	89 e5                	mov    %esp,%ebp
77306823:	57                   	push   %edi
77306824:	56                   	push   %esi
77306825:	53                   	push   %ebx
77306826:	83 ec 0c             	sub    $0xc,%esp
77306829:	8b 5d 08             	mov    0x8(%ebp),%ebx
   HEAP *heapPtr = HEAP_GetPtr( heap );
7730682c:	89 d8                	mov    %ebx,%eax
7730682e:	e8 7d f5 ff ff       	call   77305db0 <_HEAP_GetPtr>
   SUBHEAP *subheap;
   ULONG flags;
   HEAP **pptr;

   DPRINT("%08x\n", heap );
   if (!heapPtr)
      return heap;
77306833:	89 da                	mov    %ebx,%edx
77306835:	89 c6                	mov    %eax,%esi
77306837:	85 c0                	test   %eax,%eax
77306839:	74 0b                	je     77306846 <_RtlDestroyHeap@4+0x26>
 struct _PEB * pPeb;

#if defined(__GNUC__)

 __asm__ __volatile__
7730683b:	64 a1 30 00 00 00    	mov    %fs:0x30,%eax
77306841:	39 58 18             	cmp    %ebx,0x18(%eax)
77306844:	75 0c                	jne    77306852 <_RtlDestroyHeap@4+0x32>

   if (heap == NtCurrentPeb()->ProcessHeap) 
      return heap; /* cannot delete the main process heap */
 
   /* remove it from the per-process list */
   RtlEnterCriticalSection (&RtlpProcessHeapsListLock);
   
   pptr = (HEAP**)&NtCurrentPeb()->ProcessHeaps;
   while (*pptr && *pptr != heapPtr) pptr = &(*pptr)->next;
   if (*pptr) *pptr = (*pptr)->next;
   NtCurrentPeb()->NumberOfHeaps--;
   
   RtlLeaveCriticalSection (&RtlpProcessHeapsListLock);

   RtlDeleteCriticalSection( &heapPtr->critSection );
   subheap = &heapPtr->subheap;
   // We must save the flags. The first subheap is located after
   // the heap structure. If we release the first subheap,
   // we release also the heap structure.
   flags = heapPtr->flags;
   while (subheap)
   {
      SUBHEAP *next = subheap->next;
      ULONG dummySize = 0;
      ZwFreeVirtualMemory(NtCurrentProcess(),
                          (PVOID*)&subheap,
                          &dummySize,
                          MEM_RELEASE);
      subheap = next;
   }
   return (HANDLE)NULL;
}
77306846:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77306849:	89 d0                	mov    %edx,%eax
7730684b:	5b                   	pop    %ebx
7730684c:	5e                   	pop    %esi
7730684d:	5f                   	pop    %edi
7730684e:	5d                   	pop    %ebp
7730684f:	c2 04 00             	ret    $0x4
77306852:	83 ec 0c             	sub    $0xc,%esp
77306855:	68 50 c0 30 77       	push   $0x7730c050
7730685a:	e8 d1 11 00 00       	call   77307a30 <_RtlEnterCriticalSection@4>

#ifdef _M_IX86

static inline struct _PEB * NtCurrentPeb(void)
{
7730685f:	83 c4 0c             	add    $0xc,%esp
 struct _PEB * pPeb;

#if defined(__GNUC__)

 __asm__ __volatile__
77306862:	64 a1 30 00 00 00    	mov    %fs:0x30,%eax
77306868:	8d 90 90 00 00 00    	lea    0x90(%eax),%edx
7730686e:	8b 80 90 00 00 00    	mov    0x90(%eax),%eax
77306874:	85 c0                	test   %eax,%eax
77306876:	74 10                	je     77306888 <_RtlDestroyHeap@4+0x68>
77306878:	39 f0                	cmp    %esi,%eax
7730687a:	74 0c                	je     77306888 <_RtlDestroyHeap@4+0x68>
7730687c:	8b 02                	mov    (%edx),%eax
7730687e:	8d 50 18             	lea    0x18(%eax),%edx
77306881:	8b 40 18             	mov    0x18(%eax),%eax
77306884:	85 c0                	test   %eax,%eax
77306886:	75 f0                	jne    77306878 <_RtlDestroyHeap@4+0x58>
77306888:	8b 02                	mov    (%edx),%eax
7730688a:	85 c0                	test   %eax,%eax
7730688c:	74 05                	je     77306893 <_RtlDestroyHeap@4+0x73>
7730688e:	8b 40 18             	mov    0x18(%eax),%eax
77306891:	89 02                	mov    %eax,(%edx)
 struct _PEB * pPeb;

#if defined(__GNUC__)

 __asm__ __volatile__
77306893:	64 a1 30 00 00 00    	mov    %fs:0x30,%eax
77306899:	8b 90 88 00 00 00    	mov    0x88(%eax),%edx
7730689f:	83 ec 0c             	sub    $0xc,%esp

#ifdef _M_IX86

static inline struct _PEB * NtCurrentPeb(void)
{
773068a2:	4a                   	dec    %edx
773068a3:	89 90 88 00 00 00    	mov    %edx,0x88(%eax)
773068a9:	68 50 c0 30 77       	push   $0x7730c050
773068ae:	e8 6d 11 00 00       	call   77307a20 <_RtlLeaveCriticalSection@4>
773068b3:	8d 46 6c             	lea    0x6c(%esi),%eax
773068b6:	50                   	push   %eax
773068b7:	e8 84 11 00 00       	call   77307a40 <_RtlDeleteCriticalSection@4>
773068bc:	89 f0                	mov    %esi,%eax
773068be:	83 c4 0c             	add    $0xc,%esp
773068c1:	89 75 ec             	mov    %esi,0xffffffec(%ebp)
773068c4:	85 f6                	test   %esi,%esi
773068c6:	74 29                	je     773068f1 <_RtlDestroyHeap@4+0xd1>
773068c8:	8d 7d f0             	lea    0xfffffff0(%ebp),%edi
773068cb:	8d 75 ec             	lea    0xffffffec(%ebp),%esi
773068ce:	89 f6                	mov    %esi,%esi
773068d0:	8b 58 0c             	mov    0xc(%eax),%ebx
773068d3:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
773068da:	68 00 80 00 00       	push   $0x8000
773068df:	57                   	push   %edi
773068e0:	56                   	push   %esi
773068e1:	6a ff                	push   $0xffffffff
773068e3:	e8 f8 10 00 00       	call   773079e0 <_ZwFreeVirtualMemory@16>
773068e8:	89 5d ec             	mov    %ebx,0xffffffec(%ebp)
773068eb:	89 d8                	mov    %ebx,%eax
773068ed:	85 db                	test   %ebx,%ebx
773068ef:	75 df                	jne    773068d0 <_RtlDestroyHeap@4+0xb0>
773068f1:	31 d2                	xor    %edx,%edx
773068f3:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773068f6:	89 d0                	mov    %edx,%eax
773068f8:	5b                   	pop    %ebx
773068f9:	5e                   	pop    %esi
773068fa:	5f                   	pop    %edi
773068fb:	5d                   	pop    %ebp
773068fc:	c2 04 00             	ret    $0x4
773068ff:	90                   	nop    

77306900 <_RtlAllocateHeap@12>:


/***********************************************************************
 *           HeapAlloc   (KERNEL32.334)
 * RETURNS
 * Pointer to allocated memory block
 * NULL: Failure
 * 0x7d030f60--invalid flags in RtlHeapAllocate
 * @implemented
 */
PVOID STDCALL
RtlAllocateHeap(HANDLE heap,   /* [in] Handle of private heap block */
                ULONG flags,   /* [in] Heap allocation control flags */
                ULONG size)    /* [in] Number of bytes to allocate */
{
77306900:	55                   	push   %ebp
77306901:	89 e5                	mov    %esp,%ebp
77306903:	57                   	push   %edi
77306904:	56                   	push   %esi
77306905:	53                   	push   %ebx
77306906:	83 ec 0c             	sub    $0xc,%esp
77306909:	8b 45 08             	mov    0x8(%ebp),%eax
7730690c:	8b 7d 0c             	mov    0xc(%ebp),%edi
   ARENA_FREE *pArena;
   ARENA_INUSE *pInUse;
   SUBHEAP *subheap;
   HEAP *heapPtr = HEAP_GetPtr( heap );
7730690f:	e8 9c f4 ff ff       	call   77305db0 <_HEAP_GetPtr>
77306914:	8b 75 10             	mov    0x10(%ebp),%esi

   /* Validate the parameters */

   if (!heapPtr)
77306917:	85 c0                	test   %eax,%eax
77306919:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
7730691c:	0f 84 02 01 00 00    	je     77306a24 <_RtlAllocateHeap@12+0x124>
   {
      if (flags & HEAP_GENERATE_EXCEPTIONS)
         RtlRaiseStatus( STATUS_NO_MEMORY );
      return NULL;
   }
   flags &= HEAP_GENERATE_EXCEPTIONS | HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY;
   flags |= heapPtr->flags;
77306922:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
77306925:	83 e7 0d             	and    $0xd,%edi
77306928:	8b 90 84 00 00 00    	mov    0x84(%eax),%edx
7730692e:	09 d7                	or     %edx,%edi
   if (!(flags & HEAP_NO_SERIALIZE))
77306930:	89 f8                	mov    %edi,%eax
77306932:	83 e0 01             	and    $0x1,%eax
77306935:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
77306938:	0f 84 a2 00 00 00    	je     773069e0 <_RtlAllocateHeap@12+0xe0>
      RtlEnterCriticalSection( &heapPtr->critSection );
   size = (size + 7) & ~7;
7730693e:	83 c6 07             	add    $0x7,%esi
77306941:	83 e6 f8             	and    $0xfffffff8,%esi
   if (size < HEAP_MIN_BLOCK_SIZE)
77306944:	83 fe 17             	cmp    $0x17,%esi
77306947:	76 77                	jbe    773069c0 <_RtlAllocateHeap@12+0xc0>
      size = HEAP_MIN_BLOCK_SIZE;

   /* Locate a suitable free block */

   if (!(pArena = HEAP_FindFreeBlock( heapPtr, size, &subheap )))
77306949:	83 ec 0c             	sub    $0xc,%esp
7730694c:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
7730694f:	89 f2                	mov    %esi,%edx
77306951:	50                   	push   %eax
77306952:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
77306955:	e8 b6 f8 ff ff       	call   77306210 <_HEAP_FindFreeBlock>
7730695a:	83 c4 10             	add    $0x10,%esp
7730695d:	89 c3                	mov    %eax,%ebx
7730695f:	85 c0                	test   %eax,%eax
77306961:	0f 84 a4 00 00 00    	je     77306a0b <_RtlAllocateHeap@12+0x10b>
   {
      DPRINT("(%08x,%08lx,%08lx): returning NULL\n",
            heap, flags, size  );
      if (!(flags & HEAP_NO_SERIALIZE))
         RtlLeaveCriticalSection( &heapPtr->critSection );
      if (flags & HEAP_GENERATE_EXCEPTIONS)
         RtlRaiseStatus( STATUS_NO_MEMORY );
      return NULL;
   }

   /* Remove the arena from the free list */

   pArena->next->prev = pArena->prev;
77306967:	8b 50 08             	mov    0x8(%eax),%edx
7730696a:	8b 40 0c             	mov    0xc(%eax),%eax
7730696d:	89 42 0c             	mov    %eax,0xc(%edx)
   pArena->prev->next = pArena->next;
77306970:	8b 43 0c             	mov    0xc(%ebx),%eax
77306973:	89 50 08             	mov    %edx,0x8(%eax)

   /* Build the in-use arena */

   pInUse = (ARENA_INUSE *)pArena;
   pInUse->size      = (pInUse->size & ~ARENA_FLAG_FREE)
77306976:	8b 03                	mov    (%ebx),%eax
77306978:	83 e0 fe             	and    $0xfffffffe,%eax
7730697b:	83 c0 08             	add    $0x8,%eax
7730697e:	89 03                	mov    %eax,(%ebx)
 struct _TEB * pTeb;

#if defined(__GNUC__)
 /* FIXME: instead of hardcoded offsets, use offsetof() - if possible */
 __asm__ __volatile__
77306980:	64 a1 18 00 00 00    	mov    %fs:0x18,%eax
                       + sizeof(ARENA_FREE) - sizeof(ARENA_INUSE);
   pInUse->threadId  = (ULONG)NtCurrentTeb()->Cid.UniqueThread;
   pInUse->magic     = ARENA_INUSE_MAGIC;

   /* Shrink the block */

   HEAP_ShrinkBlock( subheap, pInUse, size );
77306986:	83 ec 0c             	sub    $0xc,%esp

#if defined(_M_IX86)
/* on the x86, the TEB is contained in the FS segment */
static inline struct _TEB * NtCurrentTeb(void)
{
77306989:	8b 40 24             	mov    0x24(%eax),%eax
7730698c:	66 89 43 04          	mov    %ax,0x4(%ebx)
77306990:	66 c7 43 06 42 48    	movw   $0x4842,0x6(%ebx)
77306996:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
77306999:	56                   	push   %esi
7730699a:	89 da                	mov    %ebx,%edx
7730699c:	8d 73 08             	lea    0x8(%ebx),%esi
7730699f:	e8 1c f6 ff ff       	call   77305fc0 <_HEAP_ShrinkBlock>

   if (flags & HEAP_ZERO_MEMORY)
773069a4:	83 c4 10             	add    $0x10,%esp
773069a7:	83 e7 08             	and    $0x8,%edi
773069aa:	75 4b                	jne    773069f7 <_RtlAllocateHeap@12+0xf7>
      memset( pInUse + 1, 0, pInUse->size & ARENA_SIZE_MASK );
   else if (TRACE_ON(heap))
      memset( pInUse + 1, ARENA_INUSE_FILLER, pInUse->size & ARENA_SIZE_MASK );

   if (!(flags & HEAP_NO_SERIALIZE))
773069ac:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
773069af:	85 c9                	test   %ecx,%ecx
773069b1:	74 14                	je     773069c7 <_RtlAllocateHeap@12+0xc7>
      RtlLeaveCriticalSection( &heapPtr->critSection );

   DPRINT("(%08x,%08lx,%08lx): returning %p\n",
         heap, flags, size, (PVOID)(pInUse + 1) );
   return (PVOID)(pInUse + 1);
773069b3:	89 f0                	mov    %esi,%eax
}
773069b5:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773069b8:	5b                   	pop    %ebx
773069b9:	5e                   	pop    %esi
773069ba:	5f                   	pop    %edi
773069bb:	5d                   	pop    %ebp
773069bc:	c2 0c 00             	ret    $0xc
773069bf:	90                   	nop    
773069c0:	be 18 00 00 00       	mov    $0x18,%esi
773069c5:	eb 82                	jmp    77306949 <_RtlAllocateHeap@12+0x49>
773069c7:	83 ec 0c             	sub    $0xc,%esp
773069ca:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
773069cd:	83 c0 6c             	add    $0x6c,%eax
773069d0:	50                   	push   %eax
773069d1:	e8 4a 10 00 00       	call   77307a20 <_RtlLeaveCriticalSection@4>
773069d6:	83 c4 0c             	add    $0xc,%esp
773069d9:	eb d8                	jmp    773069b3 <_RtlAllocateHeap@12+0xb3>
773069db:	90                   	nop    
773069dc:	8d 74 26 00          	lea    0x0(%esi),%esi
773069e0:	83 ec 0c             	sub    $0xc,%esp
773069e3:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
773069e6:	83 c0 6c             	add    $0x6c,%eax
773069e9:	50                   	push   %eax
773069ea:	e8 41 10 00 00       	call   77307a30 <_RtlEnterCriticalSection@4>
773069ef:	83 c4 0c             	add    $0xc,%esp
773069f2:	e9 47 ff ff ff       	jmp    7730693e <_RtlAllocateHeap@12+0x3e>
773069f7:	57                   	push   %edi
773069f8:	8b 03                	mov    (%ebx),%eax
773069fa:	83 e0 fc             	and    $0xfffffffc,%eax
773069fd:	50                   	push   %eax
773069fe:	6a 00                	push   $0x0
77306a00:	56                   	push   %esi
77306a01:	e8 8a 0f 00 00       	call   77307990 <_memset>
77306a06:	83 c4 10             	add    $0x10,%esp
77306a09:	eb a1                	jmp    773069ac <_RtlAllocateHeap@12+0xac>
77306a0b:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
77306a0e:	85 c0                	test   %eax,%eax
77306a10:	75 12                	jne    77306a24 <_RtlAllocateHeap@12+0x124>
77306a12:	83 ec 0c             	sub    $0xc,%esp
77306a15:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
77306a18:	83 c0 6c             	add    $0x6c,%eax
77306a1b:	50                   	push   %eax
77306a1c:	e8 ff 0f 00 00       	call   77307a20 <_RtlLeaveCriticalSection@4>
77306a21:	83 c4 0c             	add    $0xc,%esp
77306a24:	83 e7 04             	and    $0x4,%edi
77306a27:	75 04                	jne    77306a2d <_RtlAllocateHeap@12+0x12d>
77306a29:	31 c0                	xor    %eax,%eax
77306a2b:	eb 88                	jmp    773069b5 <_RtlAllocateHeap@12+0xb5>
77306a2d:	83 ec 0c             	sub    $0xc,%esp
77306a30:	68 17 00 00 c0       	push   $0xc0000017
77306a35:	e8 d6 07 00 00       	call   77307210 <_RtlRaiseStatus@4>
77306a3a:	31 c0                	xor    %eax,%eax
77306a3c:	83 c4 0c             	add    $0xc,%esp
77306a3f:	e9 71 ff ff ff       	jmp    773069b5 <_RtlAllocateHeap@12+0xb5>
77306a44:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77306a4a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

77306a50 <_RtlFreeHeap@12>:


/***********************************************************************
 *           HeapFree   (KERNEL32.338)
 * RETURNS
 * TRUE: Success
 * FALSE: Failure
 *
 * @implemented
 */
BOOLEAN STDCALL RtlFreeHeap(
   HANDLE heap, /* [in] Handle of heap */
   ULONG flags,   /* [in] Heap freeing flags */
   PVOID ptr     /* [in] Address of memory to free */
)
{
77306a50:	55                   	push   %ebp
77306a51:	89 e5                	mov    %esp,%ebp
77306a53:	57                   	push   %edi
77306a54:	56                   	push   %esi
77306a55:	53                   	push   %ebx
77306a56:	83 ec 0c             	sub    $0xc,%esp
   ARENA_INUSE *pInUse;
   SUBHEAP *subheap;
   HEAP *heapPtr = HEAP_GetPtr( heap );
77306a59:	8b 45 08             	mov    0x8(%ebp),%eax
77306a5c:	8b 5d 0c             	mov    0xc(%ebp),%ebx
77306a5f:	e8 4c f3 ff ff       	call   77305db0 <_HEAP_GetPtr>
77306a64:	8b 7d 10             	mov    0x10(%ebp),%edi
77306a67:	89 c6                	mov    %eax,%esi

   /* Validate the parameters */

   if (!heapPtr)
      return FALSE;
77306a69:	31 c0                	xor    %eax,%eax
77306a6b:	85 f6                	test   %esi,%esi
77306a6d:	74 3b                	je     77306aaa <_RtlFreeHeap@12+0x5a>
   if (!ptr)  /* Freeing a NULL ptr is doesn't indicate an error in Win2k */
   {
      DPRINT("(%08x,%08lx,%p): asked to free NULL\n",
           heap, flags, ptr );
      return TRUE;
77306a6f:	b0 01                	mov    $0x1,%al
77306a71:	85 ff                	test   %edi,%edi
77306a73:	74 35                	je     77306aaa <_RtlFreeHeap@12+0x5a>
   }

   flags &= HEAP_NO_SERIALIZE;
77306a75:	83 e3 01             	and    $0x1,%ebx
   flags |= heapPtr->flags;
77306a78:	8b 86 84 00 00 00    	mov    0x84(%esi),%eax
77306a7e:	09 c3                	or     %eax,%ebx
   if (!(flags & HEAP_NO_SERIALIZE))
77306a80:	83 e3 01             	and    $0x1,%ebx
77306a83:	89 5d f0             	mov    %ebx,0xfffffff0(%ebp)
77306a86:	74 2c                	je     77306ab4 <_RtlFreeHeap@12+0x64>
      RtlEnterCriticalSection( &heapPtr->critSection );
   if (!HEAP_IsRealArena( heap, HEAP_NO_SERIALIZE, ptr, QUIET ))
77306a88:	50                   	push   %eax
77306a89:	50                   	push   %eax
77306a8a:	6a 01                	push   $0x1
77306a8c:	57                   	push   %edi
77306a8d:	ba 01 00 00 00       	mov    $0x1,%edx
77306a92:	8b 45 08             	mov    0x8(%ebp),%eax
77306a95:	e8 a6 fa ff ff       	call   77306540 <_HEAP_IsRealArena>
77306a9a:	83 c4 10             	add    $0x10,%esp
77306a9d:	84 c0                	test   %al,%al
77306a9f:	75 3f                	jne    77306ae0 <_RtlFreeHeap@12+0x90>
   {
      if (!(flags & HEAP_NO_SERIALIZE))
77306aa1:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
77306aa4:	85 c0                	test   %eax,%eax
77306aa6:	74 6e                	je     77306b16 <_RtlFreeHeap@12+0xc6>
         RtlLeaveCriticalSection( &heapPtr->critSection );
      DPRINT("(%08x,%08lx,%p): returning FALSE\n",
            heap, flags, ptr );
      return FALSE;
77306aa8:	31 c0                	xor    %eax,%eax
   }

   /* Turn the block into a free block */

   pInUse  = (ARENA_INUSE *)ptr - 1;
   subheap = HEAP_FindSubHeap( heapPtr, pInUse );
   HEAP_MakeInUseBlockFree( subheap, pInUse, heapPtr->flags );

   if (!(flags & HEAP_NO_SERIALIZE))
      RtlLeaveCriticalSection( &heapPtr->critSection );

   DPRINT("(%08x,%08lx,%p): returning TRUE\n",
         heap, flags, ptr );
   return TRUE;
}
77306aaa:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77306aad:	5b                   	pop    %ebx
77306aae:	5e                   	pop    %esi
77306aaf:	5f                   	pop    %edi
77306ab0:	5d                   	pop    %ebp
77306ab1:	c2 0c 00             	ret    $0xc
77306ab4:	83 ec 0c             	sub    $0xc,%esp
77306ab7:	8d 46 6c             	lea    0x6c(%esi),%eax
77306aba:	50                   	push   %eax
77306abb:	e8 70 0f 00 00       	call   77307a30 <_RtlEnterCriticalSection@4>
77306ac0:	83 c4 0c             	add    $0xc,%esp
77306ac3:	ba 01 00 00 00       	mov    $0x1,%edx
77306ac8:	50                   	push   %eax
77306ac9:	50                   	push   %eax
77306aca:	6a 01                	push   $0x1
77306acc:	57                   	push   %edi
77306acd:	8b 45 08             	mov    0x8(%ebp),%eax
77306ad0:	e8 6b fa ff ff       	call   77306540 <_HEAP_IsRealArena>
77306ad5:	83 c4 10             	add    $0x10,%esp
77306ad8:	84 c0                	test   %al,%al
77306ada:	74 c5                	je     77306aa1 <_RtlFreeHeap@12+0x51>
77306adc:	8d 74 26 00          	lea    0x0(%esi),%esi
77306ae0:	8d 5f f8             	lea    0xfffffff8(%edi),%ebx
77306ae3:	89 f0                	mov    %esi,%eax
77306ae5:	89 da                	mov    %ebx,%edx
77306ae7:	e8 e4 f2 ff ff       	call   77305dd0 <_HEAP_FindSubHeap>
77306aec:	83 ec 0c             	sub    $0xc,%esp
77306aef:	8b be 84 00 00 00    	mov    0x84(%esi),%edi
77306af5:	89 da                	mov    %ebx,%edx
77306af7:	57                   	push   %edi
77306af8:	e8 f3 f3 ff ff       	call   77305ef0 <_HEAP_MakeInUseBlockFree>
77306afd:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
77306b00:	83 c4 10             	add    $0x10,%esp
77306b03:	85 c9                	test   %ecx,%ecx
77306b05:	74 20                	je     77306b27 <_RtlFreeHeap@12+0xd7>
77306b07:	b8 01 00 00 00       	mov    $0x1,%eax
77306b0c:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77306b0f:	5b                   	pop    %ebx
77306b10:	5e                   	pop    %esi
77306b11:	5f                   	pop    %edi
77306b12:	5d                   	pop    %ebp
77306b13:	c2 0c 00             	ret    $0xc
77306b16:	83 ec 0c             	sub    $0xc,%esp
77306b19:	8d 46 6c             	lea    0x6c(%esi),%eax
77306b1c:	50                   	push   %eax
77306b1d:	e8 fe 0e 00 00       	call   77307a20 <_RtlLeaveCriticalSection@4>
77306b22:	83 c4 0c             	add    $0xc,%esp
77306b25:	eb 81                	jmp    77306aa8 <_RtlFreeHeap@12+0x58>
77306b27:	83 ec 0c             	sub    $0xc,%esp
77306b2a:	8d 46 6c             	lea    0x6c(%esi),%eax
77306b2d:	50                   	push   %eax
77306b2e:	e8 ed 0e 00 00       	call   77307a20 <_RtlLeaveCriticalSection@4>
77306b33:	b8 01 00 00 00       	mov    $0x1,%eax
77306b38:	83 c4 0c             	add    $0xc,%esp
77306b3b:	eb cf                	jmp    77306b0c <_RtlFreeHeap@12+0xbc>
77306b3d:	8d 76 00             	lea    0x0(%esi),%esi

77306b40 <_RtlReAllocateHeap@16>:


/***********************************************************************
 *           RtlReAllocateHeap
 * PARAMS
 *   Heap   [in] Handle of heap block
 *   Flags    [in] Heap reallocation flags
 *   Ptr,    [in] Address of memory to reallocate
 *   Size     [in] Number of bytes to reallocate
 *
 * RETURNS
 * Pointer to reallocated memory block
 * NULL: Failure
 * 0x7d030f60--invalid flags in RtlHeapAllocate
 * @implemented
 */
PVOID STDCALL RtlReAllocateHeap(
   HANDLE Heap,
   ULONG Flags,
   PVOID Ptr,
   ULONG Size
)
{
77306b40:	55                   	push   %ebp
   ARENA_INUSE *pArena;
   ULONG oldSize;
   HEAP *heapPtr;
   SUBHEAP *subheap;

   if (!Ptr)
      return FALSE;
77306b41:	31 c0                	xor    %eax,%eax
77306b43:	89 e5                	mov    %esp,%ebp
77306b45:	57                   	push   %edi
77306b46:	56                   	push   %esi
77306b47:	53                   	push   %ebx
77306b48:	83 ec 2c             	sub    $0x2c,%esp
77306b4b:	8b 55 10             	mov    0x10(%ebp),%edx
77306b4e:	8b 75 0c             	mov    0xc(%ebp),%esi
77306b51:	8b 7d 14             	mov    0x14(%ebp),%edi
77306b54:	85 d2                	test   %edx,%edx
77306b56:	0f 84 63 01 00 00    	je     77306cbf <_RtlReAllocateHeap@16+0x17f>
   if (!(heapPtr = HEAP_GetPtr( Heap )))
77306b5c:	8b 45 08             	mov    0x8(%ebp),%eax
77306b5f:	e8 4c f2 ff ff       	call   77305db0 <_HEAP_GetPtr>
77306b64:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
      return FALSE;
77306b67:	31 c0                	xor    %eax,%eax
77306b69:	8b 5d dc             	mov    0xffffffdc(%ebp),%ebx
77306b6c:	85 db                	test   %ebx,%ebx
77306b6e:	0f 84 4b 01 00 00    	je     77306cbf <_RtlReAllocateHeap@16+0x17f>

   /* Validate the parameters */

   Flags &= HEAP_GENERATE_EXCEPTIONS | HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY |
            HEAP_REALLOC_IN_PLACE_ONLY;
   Flags |= heapPtr->flags;
77306b74:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   Size = (Size + 7) & ~7;
77306b77:	83 c7 07             	add    $0x7,%edi
77306b7a:	83 e6 1d             	and    $0x1d,%esi
77306b7d:	83 e7 f8             	and    $0xfffffff8,%edi
77306b80:	8b 88 84 00 00 00    	mov    0x84(%eax),%ecx
77306b86:	09 ce                	or     %ecx,%esi
   if (Size < HEAP_MIN_BLOCK_SIZE)
77306b88:	83 ff 17             	cmp    $0x17,%edi
77306b8b:	0f 86 3f 01 00 00    	jbe    77306cd0 <_RtlReAllocateHeap@16+0x190>
      Size = HEAP_MIN_BLOCK_SIZE;

   if (!(Flags & HEAP_NO_SERIALIZE))
77306b91:	89 f3                	mov    %esi,%ebx
77306b93:	83 e3 01             	and    $0x1,%ebx
77306b96:	0f 84 44 01 00 00    	je     77306ce0 <_RtlReAllocateHeap@16+0x1a0>
      RtlEnterCriticalSection( &heapPtr->critSection );
   if (!HEAP_IsRealArena( Heap, HEAP_NO_SERIALIZE, Ptr, QUIET ))
77306b9c:	52                   	push   %edx
77306b9d:	52                   	push   %edx
77306b9e:	6a 01                	push   $0x1
77306ba0:	8b 45 10             	mov    0x10(%ebp),%eax
77306ba3:	ba 01 00 00 00       	mov    $0x1,%edx
77306ba8:	50                   	push   %eax
77306ba9:	8b 45 08             	mov    0x8(%ebp),%eax
77306bac:	e8 8f f9 ff ff       	call   77306540 <_HEAP_IsRealArena>
77306bb1:	83 c4 10             	add    $0x10,%esp
77306bb4:	84 c0                	test   %al,%al
77306bb6:	0f 84 56 01 00 00    	je     77306d12 <_RtlReAllocateHeap@16+0x1d2>
   {
      if (!(Flags & HEAP_NO_SERIALIZE))
         RtlLeaveCriticalSection( &heapPtr->critSection );
      DPRINT("(%08x,%08lx,%p,%08lx): returning NULL\n",
            Heap, Flags, Ptr, Size );
      if (Flags & HEAP_GENERATE_EXCEPTIONS)
         RtlRaiseStatus( STATUS_NO_MEMORY );
      return NULL;
   }

   /* Check if we need to grow the block */

   pArena = (ARENA_INUSE *)Ptr - 1;
77306bbc:	8b 55 10             	mov    0x10(%ebp),%edx
77306bbf:	83 ea 08             	sub    $0x8,%edx
77306bc2:	89 55 e4             	mov    %edx,0xffffffe4(%ebp)
 struct _TEB * pTeb;

#if defined(__GNUC__)
 /* FIXME: instead of hardcoded offsets, use offsetof() - if possible */
 __asm__ __volatile__
77306bc5:	64 a1 18 00 00 00    	mov    %fs:0x18,%eax
77306bcb:	8b 40 24             	mov    0x24(%eax),%eax
77306bce:	66 89 42 04          	mov    %ax,0x4(%edx)
   pArena->threadId = (ULONG)NtCurrentTeb()->Cid.UniqueThread;

   subheap = HEAP_FindSubHeap( heapPtr, pArena );
77306bd2:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
77306bd5:	e8 f6 f1 ff ff       	call   77305dd0 <_HEAP_FindSubHeap>
   oldSize = (pArena->size & ARENA_SIZE_MASK);
77306bda:	8b 4d 10             	mov    0x10(%ebp),%ecx
77306bdd:	8b 59 f8             	mov    0xfffffff8(%ecx),%ebx
77306be0:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
77306be3:	89 d8                	mov    %ebx,%eax
77306be5:	83 e0 fc             	and    $0xfffffffc,%eax
77306be8:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   if (Size > oldSize)
77306beb:	39 c7                	cmp    %eax,%edi
77306bed:	0f 86 bd 01 00 00    	jbe    77306db0 <_RtlReAllocateHeap@16+0x270>
   {
      char *pNext = (char *)(pArena + 1) + oldSize;
77306bf3:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
77306bf6:	01 c2                	add    %eax,%edx
      if ((pNext < (char *)subheap + subheap->size) &&
77306bf8:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
77306bfb:	03 00                	add    (%eax),%eax
77306bfd:	8d 4a 08             	lea    0x8(%edx),%ecx
77306c00:	39 c8                	cmp    %ecx,%eax
77306c02:	76 0c                	jbe    77306c10 <_RtlReAllocateHeap@16+0xd0>
77306c04:	8b 42 08             	mov    0x8(%edx),%eax
77306c07:	a8 01                	test   $0x1,%al
77306c09:	0f 85 32 01 00 00    	jne    77306d41 <_RtlReAllocateHeap@16+0x201>
77306c0f:	90                   	nop    
            (*(PULONG)pNext & ARENA_FLAG_FREE) &&
            (oldSize + (*(PULONG)pNext & ARENA_SIZE_MASK) + sizeof(ARENA_FREE) >= Size))
      {
         /* The next block is free and large enough */
         ARENA_FREE *pFree = (ARENA_FREE *)pNext;
         pFree->next->prev = pFree->prev;
         pFree->prev->next = pFree->next;
         pArena->size += (pFree->size & ARENA_SIZE_MASK) + sizeof(*pFree);
         if (!HEAP_Commit( subheap, (char *)pArena + sizeof(ARENA_INUSE)
                           + Size + HEAP_MIN_BLOCK_SIZE,
                           heapPtr->flags))
         {
            if (!(Flags & HEAP_NO_SERIALIZE))
               RtlLeaveCriticalSection( &heapPtr->critSection );
            if (Flags & HEAP_GENERATE_EXCEPTIONS)
               RtlRaiseStatus( STATUS_NO_MEMORY );
            return NULL;
         }
         HEAP_ShrinkBlock( subheap, pArena, Size );
      }
      else  /* Do it the hard way */
      {
         ARENA_FREE *pNew;
         ARENA_INUSE *pInUse;
         SUBHEAP *newsubheap;

         if ((Flags & HEAP_REALLOC_IN_PLACE_ONLY) ||
77306c10:	f7 c6 10 00 00 00    	test   $0x10,%esi
77306c16:	0f 85 d4 01 00 00    	jne    77306df0 <_RtlReAllocateHeap@16+0x2b0>
77306c1c:	83 ec 0c             	sub    $0xc,%esp
77306c1f:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
77306c22:	89 fa                	mov    %edi,%edx
77306c24:	50                   	push   %eax
77306c25:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
77306c28:	e8 e3 f5 ff ff       	call   77306210 <_HEAP_FindFreeBlock>
77306c2d:	83 c4 10             	add    $0x10,%esp
77306c30:	89 c3                	mov    %eax,%ebx
77306c32:	85 c0                	test   %eax,%eax
77306c34:	0f 84 b6 01 00 00    	je     77306df0 <_RtlReAllocateHeap@16+0x2b0>
               !(pNew = HEAP_FindFreeBlock( heapPtr, Size, &newsubheap )))
         {
            if (!(Flags & HEAP_NO_SERIALIZE))
               RtlLeaveCriticalSection( &heapPtr->critSection );
            if (Flags & HEAP_GENERATE_EXCEPTIONS)
               RtlRaiseStatus( STATUS_NO_MEMORY );
            return NULL;
         }

         /* Build the in-use arena */

         pNew->next->prev = pNew->prev;
77306c3a:	8b 50 08             	mov    0x8(%eax),%edx
77306c3d:	8b 40 0c             	mov    0xc(%eax),%eax
77306c40:	89 42 0c             	mov    %eax,0xc(%edx)
         pNew->prev->next = pNew->next;
77306c43:	8b 43 0c             	mov    0xc(%ebx),%eax
77306c46:	89 50 08             	mov    %edx,0x8(%eax)
         pInUse = (ARENA_INUSE *)pNew;
         pInUse->size     = (pInUse->size & ~ARENA_FLAG_FREE)
77306c49:	8b 03                	mov    (%ebx),%eax
77306c4b:	83 e0 fe             	and    $0xfffffffe,%eax
77306c4e:	83 c0 08             	add    $0x8,%eax
77306c51:	89 03                	mov    %eax,(%ebx)
 struct _TEB * pTeb;

#if defined(__GNUC__)
 /* FIXME: instead of hardcoded offsets, use offsetof() - if possible */
 __asm__ __volatile__
77306c53:	64 a1 18 00 00 00    	mov    %fs:0x18,%eax
                            + sizeof(ARENA_FREE) - sizeof(ARENA_INUSE);
         pInUse->threadId = (ULONG)NtCurrentTeb()->Cid.UniqueThread;
         pInUse->magic    = ARENA_INUSE_MAGIC;
         HEAP_ShrinkBlock( newsubheap, pInUse, Size );
77306c59:	83 ec 0c             	sub    $0xc,%esp

#if defined(_M_IX86)
/* on the x86, the TEB is contained in the FS segment */
static inline struct _TEB * NtCurrentTeb(void)
{
77306c5c:	8b 40 24             	mov    0x24(%eax),%eax
77306c5f:	66 89 43 04          	mov    %ax,0x4(%ebx)
77306c63:	89 da                	mov    %ebx,%edx
77306c65:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
77306c68:	66 c7 43 06 42 48    	movw   $0x4842,0x6(%ebx)
77306c6e:	57                   	push   %edi
77306c6f:	e8 4c f3 ff ff       	call   77305fc0 <_HEAP_ShrinkBlock>
         memcpy( pInUse + 1, pArena + 1, oldSize );
77306c74:	83 c4 0c             	add    $0xc,%esp
77306c77:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
77306c7a:	50                   	push   %eax
77306c7b:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
77306c7e:	83 c0 08             	add    $0x8,%eax
77306c81:	50                   	push   %eax
77306c82:	8d 43 08             	lea    0x8(%ebx),%eax
77306c85:	50                   	push   %eax
77306c86:	e8 a5 0c 00 00       	call   77307930 <_memcpy>

         /* Free the previous block */

         HEAP_MakeInUseBlockFree( subheap, pArena, Flags );
77306c8b:	89 34 24             	mov    %esi,(%esp)
77306c8e:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
77306c91:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
77306c94:	e8 57 f2 ff ff       	call   77305ef0 <_HEAP_MakeInUseBlockFree>
         subheap = newsubheap;
         pArena  = pInUse;
77306c99:	89 5d e4             	mov    %ebx,0xffffffe4(%ebp)
      }
   }
   else
      HEAP_ShrinkBlock( subheap, pArena, Size );  /* Shrink the block */
77306c9c:	83 c4 10             	add    $0x10,%esp

   /* Clear the extra bytes if needed */

   if (Size > oldSize)
77306c9f:	3b 7d e0             	cmp    0xffffffe0(%ebp),%edi
77306ca2:	76 0c                	jbe    77306cb0 <_RtlReAllocateHeap@16+0x170>
   {
      if (Flags & HEAP_ZERO_MEMORY)
77306ca4:	f7 c6 08 00 00 00    	test   $0x8,%esi
77306caa:	0f 85 14 01 00 00    	jne    77306dc4 <_RtlReAllocateHeap@16+0x284>
         memset( (char *)(pArena + 1) + oldSize, 0,
                 (pArena->size & ARENA_SIZE_MASK) - oldSize );
      else if (TRACE_ON(heap))
         memset( (char *)(pArena + 1) + oldSize, ARENA_INUSE_FILLER,
                 (pArena->size & ARENA_SIZE_MASK) - oldSize );
   }

   /* Return the new arena */

   if (!(Flags & HEAP_NO_SERIALIZE))
77306cb0:	83 e6 01             	and    $0x1,%esi
77306cb3:	0f 84 67 01 00 00    	je     77306e20 <_RtlReAllocateHeap@16+0x2e0>
      RtlLeaveCriticalSection( &heapPtr->critSection );

   DPRINT("(%08x,%08lx,%p,%08lx): returning %p\n",
         Heap, Flags, Ptr, Size, (PVOID)(pArena + 1) );
   return (PVOID)(pArena + 1);
77306cb9:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
77306cbc:	83 c0 08             	add    $0x8,%eax
}
77306cbf:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77306cc2:	5b                   	pop    %ebx
77306cc3:	5e                   	pop    %esi
77306cc4:	5f                   	pop    %edi
77306cc5:	5d                   	pop    %ebp
77306cc6:	c2 10 00             	ret    $0x10
77306cc9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
77306cd0:	89 f3                	mov    %esi,%ebx
77306cd2:	bf 18 00 00 00       	mov    $0x18,%edi
77306cd7:	83 e3 01             	and    $0x1,%ebx
77306cda:	0f 85 bc fe ff ff    	jne    77306b9c <_RtlReAllocateHeap@16+0x5c>
77306ce0:	83 ec 0c             	sub    $0xc,%esp
77306ce3:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
77306ce6:	83 c0 6c             	add    $0x6c,%eax
77306ce9:	50                   	push   %eax
77306cea:	e8 41 0d 00 00       	call   77307a30 <_RtlEnterCriticalSection@4>
77306cef:	83 c4 0c             	add    $0xc,%esp
77306cf2:	52                   	push   %edx
77306cf3:	52                   	push   %edx
77306cf4:	6a 01                	push   $0x1
77306cf6:	ba 01 00 00 00       	mov    $0x1,%edx
77306cfb:	8b 45 10             	mov    0x10(%ebp),%eax
77306cfe:	50                   	push   %eax
77306cff:	8b 45 08             	mov    0x8(%ebp),%eax
77306d02:	e8 39 f8 ff ff       	call   77306540 <_HEAP_IsRealArena>
77306d07:	83 c4 10             	add    $0x10,%esp
77306d0a:	84 c0                	test   %al,%al
77306d0c:	0f 85 aa fe ff ff    	jne    77306bbc <_RtlReAllocateHeap@16+0x7c>
77306d12:	85 db                	test   %ebx,%ebx
77306d14:	0f 85 e2 00 00 00    	jne    77306dfc <_RtlReAllocateHeap@16+0x2bc>
77306d1a:	83 ec 0c             	sub    $0xc,%esp
77306d1d:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
77306d20:	83 c0 6c             	add    $0x6c,%eax
77306d23:	50                   	push   %eax
77306d24:	e8 f7 0c 00 00       	call   77307a20 <_RtlLeaveCriticalSection@4>
77306d29:	83 c4 0c             	add    $0xc,%esp
77306d2c:	83 e6 04             	and    $0x4,%esi
77306d2f:	0f 85 d0 00 00 00    	jne    77306e05 <_RtlReAllocateHeap@16+0x2c5>
77306d35:	31 c0                	xor    %eax,%eax
77306d37:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77306d3a:	5b                   	pop    %ebx
77306d3b:	5e                   	pop    %esi
77306d3c:	5f                   	pop    %edi
77306d3d:	5d                   	pop    %ebp
77306d3e:	c2 10 00             	ret    $0x10
77306d41:	83 e0 fc             	and    $0xfffffffc,%eax
77306d44:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
77306d47:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
77306d4a:	8d 54 10 10          	lea    0x10(%eax,%edx,1),%edx
77306d4e:	39 fa                	cmp    %edi,%edx
77306d50:	0f 82 ba fe ff ff    	jb     77306c10 <_RtlReAllocateHeap@16+0xd0>
77306d56:	8b 51 08             	mov    0x8(%ecx),%edx
77306d59:	8b 41 0c             	mov    0xc(%ecx),%eax
77306d5c:	89 42 0c             	mov    %eax,0xc(%edx)
77306d5f:	8b 41 0c             	mov    0xc(%ecx),%eax
77306d62:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
77306d65:	89 50 08             	mov    %edx,0x8(%eax)
77306d68:	8d 44 0b 10          	lea    0x10(%ebx,%ecx,1),%eax
77306d6c:	8b 5d 10             	mov    0x10(%ebp),%ebx
77306d6f:	89 fa                	mov    %edi,%edx
77306d71:	8b 4d d8             	mov    0xffffffd8(%ebp),%ecx
77306d74:	89 43 f8             	mov    %eax,0xfffffff8(%ebx)
77306d77:	8b 5d d8             	mov    0xffffffd8(%ebp),%ebx
77306d7a:	29 da                	sub    %ebx,%edx
77306d7c:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
77306d7f:	8d 94 02 1f 00 01 00 	lea    0x1001f(%edx,%eax,1),%edx
77306d86:	8b 01                	mov    (%ecx),%eax
77306d88:	81 e2 00 00 ff ff    	and    $0xffff0000,%edx
77306d8e:	39 d0                	cmp    %edx,%eax
77306d90:	73 02                	jae    77306d94 <_RtlReAllocateHeap@16+0x254>
77306d92:	89 c2                	mov    %eax,%edx
77306d94:	8b 5d d8             	mov    0xffffffd8(%ebp),%ebx
77306d97:	8b 4b 04             	mov    0x4(%ebx),%ecx
77306d9a:	bb 01 00 00 00       	mov    $0x1,%ebx
77306d9f:	39 d1                	cmp    %edx,%ecx
77306da1:	0f 82 90 00 00 00    	jb     77306e37 <_RtlReAllocateHeap@16+0x2f7>
77306da7:	85 db                	test   %ebx,%ebx
77306da9:	74 45                	je     77306df0 <_RtlReAllocateHeap@16+0x2b0>
77306dab:	90                   	nop    
77306dac:	8d 74 26 00          	lea    0x0(%esi),%esi
77306db0:	83 ec 0c             	sub    $0xc,%esp
77306db3:	57                   	push   %edi
77306db4:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
77306db7:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
77306dba:	e8 01 f2 ff ff       	call   77305fc0 <_HEAP_ShrinkBlock>
77306dbf:	e9 d8 fe ff ff       	jmp    77306c9c <_RtlReAllocateHeap@16+0x15c>
77306dc4:	51                   	push   %ecx
77306dc5:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
77306dc8:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
77306dcb:	8b 01                	mov    (%ecx),%eax
77306dcd:	83 e0 fc             	and    $0xfffffffc,%eax
77306dd0:	29 d0                	sub    %edx,%eax
77306dd2:	50                   	push   %eax
77306dd3:	6a 00                	push   $0x0
77306dd5:	8b 5d e0             	mov    0xffffffe0(%ebp),%ebx
77306dd8:	8d 44 19 08          	lea    0x8(%ecx,%ebx,1),%eax
77306ddc:	50                   	push   %eax
77306ddd:	e8 ae 0b 00 00       	call   77307990 <_memset>
77306de2:	83 c4 10             	add    $0x10,%esp
77306de5:	e9 c6 fe ff ff       	jmp    77306cb0 <_RtlReAllocateHeap@16+0x170>
77306dea:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77306df0:	f7 c6 01 00 00 00    	test   $0x1,%esi
77306df6:	0f 84 1e ff ff ff    	je     77306d1a <_RtlReAllocateHeap@16+0x1da>
77306dfc:	83 e6 04             	and    $0x4,%esi
77306dff:	0f 84 30 ff ff ff    	je     77306d35 <_RtlReAllocateHeap@16+0x1f5>
77306e05:	83 ec 0c             	sub    $0xc,%esp
77306e08:	68 17 00 00 c0       	push   $0xc0000017
77306e0d:	e8 fe 03 00 00       	call   77307210 <_RtlRaiseStatus@4>
77306e12:	31 c0                	xor    %eax,%eax
77306e14:	83 c4 0c             	add    $0xc,%esp
77306e17:	e9 1b ff ff ff       	jmp    77306d37 <_RtlReAllocateHeap@16+0x1f7>
77306e1c:	8d 74 26 00          	lea    0x0(%esi),%esi
77306e20:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
77306e23:	83 ec 0c             	sub    $0xc,%esp
77306e26:	83 c0 6c             	add    $0x6c,%eax
77306e29:	50                   	push   %eax
77306e2a:	e8 f1 0b 00 00       	call   77307a20 <_RtlLeaveCriticalSection@4>
77306e2f:	83 c4 0c             	add    $0xc,%esp
77306e32:	e9 82 fe ff ff       	jmp    77306cb9 <_RtlReAllocateHeap@16+0x179>
77306e37:	8b 5d d8             	mov    0xffffffd8(%ebp),%ebx
77306e3a:	29 ca                	sub    %ecx,%edx
77306e3c:	89 55 f0             	mov    %edx,0xfffffff0(%ebp)
77306e3f:	8d 04 19             	lea    (%ecx,%ebx,1),%eax
77306e42:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
77306e45:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
77306e48:	51                   	push   %ecx
77306e49:	51                   	push   %ecx
77306e4a:	6a 40                	push   $0x40
77306e4c:	68 00 10 00 00       	push   $0x1000
77306e51:	50                   	push   %eax
77306e52:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
77306e55:	6a 00                	push   $0x0
77306e57:	50                   	push   %eax
77306e58:	6a ff                	push   $0xffffffff
77306e5a:	e8 b1 0b 00 00       	call   77307a10 <_NtAllocateVirtualMemory@24>
77306e5f:	5b                   	pop    %ebx
77306e60:	31 db                	xor    %ebx,%ebx
77306e62:	5a                   	pop    %edx
77306e63:	85 c0                	test   %eax,%eax
77306e65:	0f 88 3c ff ff ff    	js     77306da7 <_RtlReAllocateHeap@16+0x267>
77306e6b:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
77306e6e:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
77306e71:	b3 01                	mov    $0x1,%bl
77306e73:	8b 4a 04             	mov    0x4(%edx),%ecx
77306e76:	01 c1                	add    %eax,%ecx
77306e78:	89 4a 04             	mov    %ecx,0x4(%edx)
77306e7b:	e9 27 ff ff ff       	jmp    77306da7 <_RtlReAllocateHeap@16+0x267>

77306e80 <_RtlCompactHeap@8>:


/***********************************************************************
 *           RtlCompactHeap
 *
 * @unimplemented
 */
ULONG STDCALL
RtlCompactHeap(HANDLE Heap,
		ULONG Flags)
{
77306e80:	55                   	push   %ebp
77306e81:	89 e5                	mov    %esp,%ebp
77306e83:	51                   	push   %ecx
77306e84:	51                   	push   %ecx
   UNIMPLEMENTED;
77306e85:	68 a2 05 00 00       	push   $0x5a2
77306e8a:	68 52 ab 30 77       	push   $0x7730ab52
77306e8f:	68 8a ab 30 77       	push   $0x7730ab8a
77306e94:	68 9c ab 30 77       	push   $0x7730ab9c
77306e99:	e8 e2 0a 00 00       	call   77307980 <_DbgPrint>
   return 0;
}
77306e9e:	31 c0                	xor    %eax,%eax
77306ea0:	c9                   	leave  
77306ea1:	c2 08 00             	ret    $0x8
77306ea4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77306eaa:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

77306eb0 <_RtlLockHeap@4>:


/***********************************************************************
 *           RtlLockHeap
 * Attempts to acquire the critical section object for a specified heap.
 *
 * PARAMS
 *   Heap  [in] Handle of heap to lock for exclusive access
 *
 * RETURNS
 * TRUE: Success
 * FALSE: Failure
 *
 * @implemented
 */
BOOLEAN STDCALL
RtlLockHeap(IN HANDLE Heap)
{
77306eb0:	55                   	push   %ebp
77306eb1:	89 e5                	mov    %esp,%ebp
77306eb3:	50                   	push   %eax
77306eb4:	50                   	push   %eax
77306eb5:	8b 45 08             	mov    0x8(%ebp),%eax
   HEAP *heapPtr = HEAP_GetPtr( Heap );
77306eb8:	e8 f3 ee ff ff       	call   77305db0 <_HEAP_GetPtr>
   if (!heapPtr)
      return FALSE;
77306ebd:	31 d2                	xor    %edx,%edx
77306ebf:	85 c0                	test   %eax,%eax
77306ec1:	74 11                	je     77306ed4 <_RtlLockHeap@4+0x24>
   RtlEnterCriticalSection( &heapPtr->critSection );
77306ec3:	83 ec 0c             	sub    $0xc,%esp
77306ec6:	83 c0 6c             	add    $0x6c,%eax
77306ec9:	50                   	push   %eax
77306eca:	e8 61 0b 00 00       	call   77307a30 <_RtlEnterCriticalSection@4>
   return TRUE;
77306ecf:	ba 01 00 00 00       	mov    $0x1,%edx
}
77306ed4:	89 d0                	mov    %edx,%eax
77306ed6:	c9                   	leave  
77306ed7:	c2 04 00             	ret    $0x4
77306eda:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

77306ee0 <_RtlUnlockHeap@4>:


/***********************************************************************
 *           RtlUnlockHeap
 * Releases ownership of the critical section object.
 *
 * PARAMS
 *   Heap  [in] Handle to the heap to unlock
 *
 * RETURNS
 * TRUE: Success
 * FALSE: Failure
 *
 * @implemented
 */
BOOLEAN STDCALL
RtlUnlockHeap(HANDLE Heap)
{
77306ee0:	55                   	push   %ebp
77306ee1:	89 e5                	mov    %esp,%ebp
77306ee3:	50                   	push   %eax
77306ee4:	50                   	push   %eax
77306ee5:	8b 45 08             	mov    0x8(%ebp),%eax
   HEAP *heapPtr = HEAP_GetPtr( Heap );
77306ee8:	e8 c3 ee ff ff       	call   77305db0 <_HEAP_GetPtr>
   if (!heapPtr)
      return FALSE;
77306eed:	31 d2                	xor    %edx,%edx
77306eef:	85 c0                	test   %eax,%eax
77306ef1:	74 11                	je     77306f04 <_RtlUnlockHeap@4+0x24>
   RtlLeaveCriticalSection( &heapPtr->critSection );
77306ef3:	83 ec 0c             	sub    $0xc,%esp
77306ef6:	83 c0 6c             	add    $0x6c,%eax
77306ef9:	50                   	push   %eax
77306efa:	e8 21 0b 00 00       	call   77307a20 <_RtlLeaveCriticalSection@4>
   return TRUE;
77306eff:	ba 01 00 00 00       	mov    $0x1,%edx
}
77306f04:	89 d0                	mov    %edx,%eax
77306f06:	c9                   	leave  
77306f07:	c2 04 00             	ret    $0x4
77306f0a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

77306f10 <_RtlSizeHeap@12>:


/***********************************************************************
 *           RtlSizeHeap
 * PARAMS
 *   Heap  [in] Handle of heap
 *   Flags   [in] Heap size control flags
 *   Ptr     [in] Address of memory to return size for
 *
 * RETURNS
 * Size in bytes of allocated memory
 * 0xffffffff: Failure
 *
 * @implemented
 */
ULONG STDCALL
RtlSizeHeap(
   HANDLE Heap,
   ULONG Flags,
   PVOID Ptr
)
{
77306f10:	55                   	push   %ebp
77306f11:	89 e5                	mov    %esp,%ebp
77306f13:	57                   	push   %edi
77306f14:	56                   	push   %esi
77306f15:	53                   	push   %ebx
77306f16:	83 ec 0c             	sub    $0xc,%esp
   ULONG ret;
   HEAP *heapPtr = HEAP_GetPtr( Heap );
77306f19:	8b 45 08             	mov    0x8(%ebp),%eax
77306f1c:	8b 5d 0c             	mov    0xc(%ebp),%ebx
77306f1f:	e8 8c ee ff ff       	call   77305db0 <_HEAP_GetPtr>
77306f24:	89 c6                	mov    %eax,%esi

   if (!heapPtr)
      return 0;
77306f26:	31 c0                	xor    %eax,%eax
77306f28:	85 f6                	test   %esi,%esi
77306f2a:	74 3f                	je     77306f6b <_RtlSizeHeap@12+0x5b>
   Flags &= HEAP_NO_SERIALIZE;
77306f2c:	83 e3 01             	and    $0x1,%ebx
   Flags |= heapPtr->flags;
77306f2f:	8b 86 84 00 00 00    	mov    0x84(%esi),%eax
77306f35:	09 c3                	or     %eax,%ebx
   if (!(Flags & HEAP_NO_SERIALIZE))
77306f37:	f6 c3 01             	test   $0x1,%bl
77306f3a:	74 4a                	je     77306f86 <_RtlSizeHeap@12+0x76>
      RtlEnterCriticalSection( &heapPtr->critSection );
   if (!HEAP_IsRealArena( Heap, HEAP_NO_SERIALIZE, Ptr, QUIET ))
77306f3c:	50                   	push   %eax
77306f3d:	50                   	push   %eax
77306f3e:	8b 45 10             	mov    0x10(%ebp),%eax
77306f41:	6a 01                	push   $0x1
77306f43:	ba 01 00 00 00       	mov    $0x1,%edx
77306f48:	50                   	push   %eax
77306f49:	8b 45 08             	mov    0x8(%ebp),%eax
77306f4c:	e8 ef f5 ff ff       	call   77306540 <_HEAP_IsRealArena>
   {
      ret = 0xffffffff;
77306f51:	83 cf ff             	or     $0xffffffff,%edi
77306f54:	83 c4 10             	add    $0x10,%esp
77306f57:	84 c0                	test   %al,%al
77306f59:	74 09                	je     77306f64 <_RtlSizeHeap@12+0x54>
   }
   else
   {
      ARENA_INUSE *pArena = (ARENA_INUSE *)Ptr - 1;
      ret = pArena->size & ARENA_SIZE_MASK;
77306f5b:	8b 45 10             	mov    0x10(%ebp),%eax
77306f5e:	8b 78 f8             	mov    0xfffffff8(%eax),%edi
77306f61:	83 e7 fc             	and    $0xfffffffc,%edi
   }
   if (!(Flags & HEAP_NO_SERIALIZE))
77306f64:	83 e3 01             	and    $0x1,%ebx
77306f67:	74 0c                	je     77306f75 <_RtlSizeHeap@12+0x65>
      RtlLeaveCriticalSection( &heapPtr->critSection );

   DPRINT("(%08x,%08lx,%p): returning %08lx\n",
         Heap, Flags, Ptr, ret );
   return ret;
77306f69:	89 f8                	mov    %edi,%eax
}
77306f6b:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77306f6e:	5b                   	pop    %ebx
77306f6f:	5e                   	pop    %esi
77306f70:	5f                   	pop    %edi
77306f71:	5d                   	pop    %ebp
77306f72:	c2 0c 00             	ret    $0xc
77306f75:	83 ec 0c             	sub    $0xc,%esp
77306f78:	8d 46 6c             	lea    0x6c(%esi),%eax
77306f7b:	50                   	push   %eax
77306f7c:	e8 9f 0a 00 00       	call   77307a20 <_RtlLeaveCriticalSection@4>
77306f81:	83 c4 0c             	add    $0xc,%esp
77306f84:	eb e3                	jmp    77306f69 <_RtlSizeHeap@12+0x59>
77306f86:	83 ec 0c             	sub    $0xc,%esp
77306f89:	8d 46 6c             	lea    0x6c(%esi),%eax
77306f8c:	50                   	push   %eax
77306f8d:	e8 9e 0a 00 00       	call   77307a30 <_RtlEnterCriticalSection@4>
77306f92:	83 c4 0c             	add    $0xc,%esp
77306f95:	eb a5                	jmp    77306f3c <_RtlSizeHeap@12+0x2c>
77306f97:	89 f6                	mov    %esi,%esi
77306f99:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77306fa0 <_RtlValidateHeap@12>:


/***********************************************************************
 *           RtlValidateHeap
 * Validates a specified heap.
 *
 * PARAMS
 *   Heap  [in] Handle to the heap
 *   Flags   [in] Bit flags that control access during operation
 *   Block  [in] Optional pointer to memory block to validate
 *
 * NOTES
 * Flags is ignored.
 *
 * RETURNS
 * TRUE: Success
 * FALSE: Failure
 *
 * @implemented
 */
BOOLEAN STDCALL RtlValidateHeap(
   HANDLE Heap,
   ULONG Flags,
   PVOID Block
)
{
77306fa0:	55                   	push   %ebp
77306fa1:	89 e5                	mov    %esp,%ebp
77306fa3:	50                   	push   %eax
77306fa4:	50                   	push   %eax
77306fa5:	8b 45 08             	mov    0x8(%ebp),%eax
   HEAP *heapPtr = HEAP_GetPtr( Heap );
77306fa8:	e8 03 ee ff ff       	call   77305db0 <_HEAP_GetPtr>
   if (!heapPtr)
      return FALSE;
77306fad:	31 d2                	xor    %edx,%edx
77306faf:	85 c0                	test   %eax,%eax
77306fb1:	74 14                	je     77306fc7 <_RtlValidateHeap@12+0x27>
   return HEAP_IsRealArena( heapPtr, Flags, Block, QUIET );
77306fb3:	8b 55 10             	mov    0x10(%ebp),%edx
77306fb6:	51                   	push   %ecx
77306fb7:	51                   	push   %ecx
77306fb8:	6a 01                	push   $0x1
77306fba:	52                   	push   %edx
77306fbb:	8b 55 0c             	mov    0xc(%ebp),%edx
77306fbe:	e8 7d f5 ff ff       	call   77306540 <_HEAP_IsRealArena>
77306fc3:	31 d2                	xor    %edx,%edx
77306fc5:	88 c2                	mov    %al,%dl
}
77306fc7:	89 d0                	mov    %edx,%eax
77306fc9:	c9                   	leave  
77306fca:	c2 0c 00             	ret    $0xc
77306fcd:	8d 76 00             	lea    0x0(%esi),%esi

77306fd0 <_RtlInitializeHeapManager>:


/***********************************************************************
 *           HeapWalk   (KERNEL32.344)
 * Enumerates the memory blocks in a specified heap.
 * See HEAP_Dump() for info on heap structure.
 *
 * TODO
 *   - handling of PROCESS_HEAP_ENTRY_MOVEABLE and
 *     PROCESS_HEAP_ENTRY_DDESHARE (needs heap.c support)
 *
 * RETURNS
 * TRUE: Success
 * FALSE: Failure
 */
#if 0
BOOLEAN STDCALL HeapWalk(
   HANDLE heap,               /* [in]  Handle to heap to enumerate */
   LPPROCESS_HEAP_ENTRY entry /* [out] Pointer to structure of enumeration info */
)
{
   HEAP *heapPtr = HEAP_GetPtr(heap);
   SUBHEAP *sub, *currentheap = NULL;
   BOOLEAN ret = FALSE;
   char *ptr;
   int region_index = 0;

   if (!heapPtr || !entry)
   {
      return FALSE;
   }

   if (!(heapPtr->flags & HEAP_NO_SERIALIZE))
      RtlEnterCriticalSection( &heapPtr->critSection );

   /* set ptr to the next arena to be examined */

   if (!entry->lpData) /* first call (init) ? */
   {
      DPRINT("begin walking of heap 0x%08x.\n", heap);
      /*HEAP_Dump(heapPtr);*/
      currentheap = &heapPtr->subheap;
      ptr = (char*)currentheap + currentheap->headerSize;
   }
   else
   {
      ptr = entry->lpData;
      sub = &heapPtr->subheap;
      while (sub)
      {
         if (((char *)ptr >= (char *)sub) &&
               ((char *)ptr < (char *)sub + sub->size))
         {
            currentheap = sub;
            break;
         }
         sub = sub->next;
         region_index++;
      }
      if (currentheap == NULL)
      {
         DPRINT("no matching subheap found, shouldn't happen !\n");
         goto HW_end;
      }

      ptr += entry->cbData; /* point to next arena */
      if (ptr > (char *)currentheap + currentheap->size - 1)
      {   /* proceed with next subheap */
         if (!(currentheap = currentheap->next))
         {  /* successfully finished */
            DPRINT("end reached.\n");
            goto HW_end;
         }
         ptr = (char*)currentheap + currentheap->headerSize;
      }
   }

   entry->wFlags = 0;
   if (*(PULONG)ptr & ARENA_FLAG_FREE)
   {
      ARENA_FREE *pArena = (ARENA_FREE *)ptr;

      /*DPRINT("free, magic: %04x\n", pArena->magic);*/

      entry->lpData = pArena + 1;
      entry->cbData = pArena->size & ARENA_SIZE_MASK;
      entry->cbOverhead = sizeof(ARENA_FREE);
      entry->wFlags = PROCESS_HEAP_UNCOMMITTED_RANGE;
   }
   else
   {
      ARENA_INUSE *pArena = (ARENA_INUSE *)ptr;

      /*DPRINT("busy, magic: %04x\n", pArena->magic);*/

      entry->lpData = pArena + 1;
      entry->cbData = pArena->size & ARENA_SIZE_MASK;
      entry->cbOverhead = sizeof(ARENA_INUSE);
      entry->wFlags = PROCESS_HEAP_ENTRY_BUSY;
      /* FIXME: can't handle PROCESS_HEAP_ENTRY_MOVEABLE
      and PROCESS_HEAP_ENTRY_DDESHARE yet */
   }

   entry->iRegionIndex = region_index;

   /* first element of heap ? */
   if (ptr == (char *)(currentheap + currentheap->headerSize))
   {
      entry->wFlags |= PROCESS_HEAP_REGION;
      entry->Foo.Region.dwCommittedSize = currentheap->commitSize;
      entry->Foo.Region.dwUnCommittedSize =
         currentheap->size - currentheap->commitSize;
      entry->Foo.Region.lpFirstBlock = /* first valid block */
         currentheap + currentheap->headerSize;
      entry->Foo.Region.lpLastBlock  = /* first invalid block */
         currentheap + currentheap->size;
   }
   ret = TRUE;

HW_end:
   if (!(heapPtr->flags & HEAP_NO_SERIALIZE))
      RtlLeaveCriticalSection( &heapPtr->critSection );

   return ret;
}
#endif


VOID
RtlInitializeHeapManager(VOID)
{
77306fd0:	55                   	push   %ebp
77306fd1:	89 e5                	mov    %esp,%ebp
77306fd3:	83 ec 14             	sub    $0x14,%esp
 struct _PEB * pPeb;

#if defined(__GNUC__)

 __asm__ __volatile__
77306fd6:	64 a1 30 00 00 00    	mov    %fs:0x30,%eax
   PPEB Peb;

   Peb = NtCurrentPeb();

   Peb->NumberOfHeaps = 0;
77306fdc:	c7 80 88 00 00 00 00 	movl   $0x0,0x88(%eax)
77306fe3:	00 00 00 
   Peb->MaximumNumberOfHeaps = -1; /* no limit */
77306fe6:	c7 80 8c 00 00 00 ff 	movl   $0xffffffff,0x8c(%eax)
77306fed:	ff ff ff 
   Peb->ProcessHeaps = NULL;
77306ff0:	c7 80 90 00 00 00 00 	movl   $0x0,0x90(%eax)
77306ff7:	00 00 00 

   RtlInitializeCriticalSection(&RtlpProcessHeapsListLock);
77306ffa:	68 50 c0 30 77       	push   $0x7730c050
77306fff:	e8 fc 09 00 00       	call   77307a00 <_RtlInitializeCriticalSection@4>
77307004:	c9                   	leave  
77307005:	c3                   	ret    
77307006:	8d 76 00             	lea    0x0(%esi),%esi
77307009:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77307010 <_RtlEnumProcessHeaps@8>:
}


/*
 * @implemented
 */
NTSTATUS STDCALL
RtlEnumProcessHeaps(PHEAP_ENUMERATION_ROUTINE HeapEnumerationRoutine,
                    PVOID lParam)
{
77307010:	55                   	push   %ebp
77307011:	89 e5                	mov    %esp,%ebp
77307013:	57                   	push   %edi
77307014:	56                   	push   %esi
77307015:	53                   	push   %ebx
77307016:	83 ec 18             	sub    $0x18,%esp
   NTSTATUS Status = STATUS_SUCCESS;
77307019:	31 f6                	xor    %esi,%esi
7730701b:	8b 7d 0c             	mov    0xc(%ebp),%edi
   HEAP** pptr;
   
   RtlEnterCriticalSection(&RtlpProcessHeapsListLock);
7730701e:	68 50 c0 30 77       	push   $0x7730c050
77307023:	e8 08 0a 00 00       	call   77307a30 <_RtlEnterCriticalSection@4>

#ifdef _M_IX86

static inline struct _PEB * NtCurrentPeb(void)
{
77307028:	83 c4 0c             	add    $0xc,%esp
 struct _PEB * pPeb;

#if defined(__GNUC__)

 __asm__ __volatile__
7730702b:	64 a1 30 00 00 00    	mov    %fs:0x30,%eax
77307031:	8d 98 90 00 00 00    	lea    0x90(%eax),%ebx

   for (pptr = (HEAP**)&NtCurrentPeb()->ProcessHeaps; *pptr; pptr = &(*pptr)->next)
77307037:	8b 80 90 00 00 00    	mov    0x90(%eax),%eax
7730703d:	85 c0                	test   %eax,%eax
7730703f:	74 1e                	je     7730705f <_RtlEnumProcessHeaps@8+0x4f>
   {
      Status = HeapEnumerationRoutine(*pptr,lParam);
77307041:	50                   	push   %eax
77307042:	50                   	push   %eax
77307043:	57                   	push   %edi
77307044:	8b 03                	mov    (%ebx),%eax
77307046:	50                   	push   %eax
77307047:	ff 55 08             	call   *0x8(%ebp)
      if (!NT_SUCCESS(Status))
7730704a:	83 c4 10             	add    $0x10,%esp
7730704d:	89 c6                	mov    %eax,%esi
7730704f:	85 c0                	test   %eax,%eax
77307051:	78 0c                	js     7730705f <_RtlEnumProcessHeaps@8+0x4f>
77307053:	8b 03                	mov    (%ebx),%eax
77307055:	8d 58 18             	lea    0x18(%eax),%ebx
77307058:	8b 40 18             	mov    0x18(%eax),%eax
7730705b:	85 c0                	test   %eax,%eax
7730705d:	75 e2                	jne    77307041 <_RtlEnumProcessHeaps@8+0x31>
         break;
   }

   RtlLeaveCriticalSection(&RtlpProcessHeapsListLock);
7730705f:	83 ec 0c             	sub    $0xc,%esp
77307062:	68 50 c0 30 77       	push   $0x7730c050
77307067:	e8 b4 09 00 00       	call   77307a20 <_RtlLeaveCriticalSection@4>

   return Status;
}
7730706c:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
7730706f:	89 f0                	mov    %esi,%eax
77307071:	5b                   	pop    %ebx
77307072:	5e                   	pop    %esi
77307073:	5f                   	pop    %edi
77307074:	5d                   	pop    %ebp
77307075:	c2 08 00             	ret    $0x8
77307078:	90                   	nop    
77307079:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

77307080 <_RtlGetProcessHeaps@8>:


/*
 * @implemented
 */
ULONG STDCALL
RtlGetProcessHeaps(ULONG HeapCount,
                   HANDLE *HeapArray)
{
77307080:	55                   	push   %ebp
77307081:	89 e5                	mov    %esp,%ebp
77307083:	56                   	push   %esi
77307084:	53                   	push   %ebx
   ULONG Result = 0;
   HEAP ** pptr;

   RtlEnterCriticalSection(&RtlpProcessHeapsListLock);
77307085:	83 ec 0c             	sub    $0xc,%esp
77307088:	8b 75 0c             	mov    0xc(%ebp),%esi
7730708b:	68 50 c0 30 77       	push   $0x7730c050
77307090:	e8 9b 09 00 00       	call   77307a30 <_RtlEnterCriticalSection@4>

#ifdef _M_IX86

static inline struct _PEB * NtCurrentPeb(void)
{
77307095:	83 c4 0c             	add    $0xc,%esp
 struct _PEB * pPeb;

#if defined(__GNUC__)

 __asm__ __volatile__
77307098:	64 a1 30 00 00 00    	mov    %fs:0x30,%eax
7730709e:	8b 98 88 00 00 00    	mov    0x88(%eax),%ebx
773070a4:	64 8b 15 30 00 00 00 	mov    %fs:0x30,%edx
773070ab:	8b 45 08             	mov    0x8(%ebp),%eax
773070ae:	39 82 88 00 00 00    	cmp    %eax,0x88(%edx)
773070b4:	77 2a                	ja     773070e0 <_RtlGetProcessHeaps@8+0x60>

   Result = NtCurrentPeb()->NumberOfHeaps;
   
   if (NtCurrentPeb()->NumberOfHeaps <= HeapCount)
   {
      int i = 0;
773070b6:	31 c9                	xor    %ecx,%ecx
 struct _PEB * pPeb;

#if defined(__GNUC__)

 __asm__ __volatile__
773070b8:	64 a1 30 00 00 00    	mov    %fs:0x30,%eax
773070be:	8d 90 90 00 00 00    	lea    0x90(%eax),%edx
      for (pptr = (HEAP**)&NtCurrentPeb()->ProcessHeaps; *pptr; pptr = &(*pptr)->next)
773070c4:	8b 80 90 00 00 00    	mov    0x90(%eax),%eax
773070ca:	eb 10                	jmp    773070dc <_RtlGetProcessHeaps@8+0x5c>
773070cc:	8d 74 26 00          	lea    0x0(%esi),%esi
      {
         HeapArray[i++] = *pptr;
773070d0:	8b 02                	mov    (%edx),%eax
773070d2:	89 04 8e             	mov    %eax,(%esi,%ecx,4)
773070d5:	41                   	inc    %ecx
773070d6:	8d 50 18             	lea    0x18(%eax),%edx
773070d9:	8b 40 18             	mov    0x18(%eax),%eax
773070dc:	85 c0                	test   %eax,%eax
773070de:	75 f0                	jne    773070d0 <_RtlGetProcessHeaps@8+0x50>
      }
   }

   RtlLeaveCriticalSection (&RtlpProcessHeapsListLock);
773070e0:	83 ec 0c             	sub    $0xc,%esp
773070e3:	68 50 c0 30 77       	push   $0x7730c050
773070e8:	e8 33 09 00 00       	call   77307a20 <_RtlLeaveCriticalSection@4>

   return Result;
}
773070ed:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
773070f0:	89 d8                	mov    %ebx,%eax
773070f2:	5b                   	pop    %ebx
773070f3:	5e                   	pop    %esi
773070f4:	5d                   	pop    %ebp
773070f5:	c2 08 00             	ret    $0x8
773070f8:	90                   	nop    
773070f9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

77307100 <_RtlValidateProcessHeaps@0>:


/*
 * @implemented
 */
BOOLEAN STDCALL
RtlValidateProcessHeaps(VOID)
{
77307100:	55                   	push   %ebp
77307101:	89 e5                	mov    %esp,%ebp
77307103:	56                   	push   %esi
77307104:	53                   	push   %ebx
   BOOLEAN Result = TRUE;
77307105:	be 01 00 00 00       	mov    $0x1,%esi
   HEAP ** pptr;

   RtlEnterCriticalSection(&RtlpProcessHeapsListLock);
7730710a:	83 ec 0c             	sub    $0xc,%esp
7730710d:	68 50 c0 30 77       	push   $0x7730c050
77307112:	e8 19 09 00 00       	call   77307a30 <_RtlEnterCriticalSection@4>

#ifdef _M_IX86

static inline struct _PEB * NtCurrentPeb(void)
{
77307117:	83 c4 0c             	add    $0xc,%esp
 struct _PEB * pPeb;

#if defined(__GNUC__)

 __asm__ __volatile__
7730711a:	64 a1 30 00 00 00    	mov    %fs:0x30,%eax
77307120:	8d 98 90 00 00 00    	lea    0x90(%eax),%ebx

   for (pptr = (HEAP**)&NtCurrentPeb()->ProcessHeaps; *pptr; pptr = &(*pptr)->next)
77307126:	8b 80 90 00 00 00    	mov    0x90(%eax),%eax
7730712c:	85 c0                	test   %eax,%eax
7730712e:	74 1e                	je     7730714e <_RtlValidateProcessHeaps@0+0x4e>
   {
      if (!RtlValidateHeap(*pptr, 0, NULL))
77307130:	50                   	push   %eax
77307131:	6a 00                	push   $0x0
77307133:	6a 00                	push   $0x0
77307135:	8b 0b                	mov    (%ebx),%ecx
77307137:	51                   	push   %ecx
77307138:	e8 63 fe ff ff       	call   77306fa0 <_RtlValidateHeap@12>
7730713d:	5a                   	pop    %edx
7730713e:	84 c0                	test   %al,%al
77307140:	74 27                	je     77307169 <_RtlValidateProcessHeaps@0+0x69>
77307142:	8b 03                	mov    (%ebx),%eax
77307144:	8d 58 18             	lea    0x18(%eax),%ebx
77307147:	8b 40 18             	mov    0x18(%eax),%eax
7730714a:	85 c0                	test   %eax,%eax
7730714c:	75 e2                	jne    77307130 <_RtlValidateProcessHeaps@0+0x30>
      {
         Result = FALSE;
         break;
      }
   }

   RtlLeaveCriticalSection (&RtlpProcessHeapsListLock);
7730714e:	83 ec 0c             	sub    $0xc,%esp
77307151:	68 50 c0 30 77       	push   $0x7730c050
77307156:	e8 c5 08 00 00       	call   77307a20 <_RtlLeaveCriticalSection@4>

   return Result;
7730715b:	89 f0                	mov    %esi,%eax
}
7730715d:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
77307160:	25 ff 00 00 00       	and    $0xff,%eax
77307165:	5b                   	pop    %ebx
77307166:	5e                   	pop    %esi
77307167:	5d                   	pop    %ebp
77307168:	c3                   	ret    
77307169:	83 ec 0c             	sub    $0xc,%esp
7730716c:	31 f6                	xor    %esi,%esi
7730716e:	68 50 c0 30 77       	push   $0x7730c050
77307173:	e8 a8 08 00 00       	call   77307a20 <_RtlLeaveCriticalSection@4>
77307178:	89 f0                	mov    %esi,%eax
7730717a:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
7730717d:	25 ff 00 00 00       	and    $0xff,%eax
77307182:	5b                   	pop    %ebx
77307183:	5e                   	pop    %esi
77307184:	5d                   	pop    %ebp
77307185:	c3                   	ret    
77307186:	8d 76 00             	lea    0x0(%esi),%esi
77307189:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77307190 <_RtlZeroHeap@8>:


/*
 * @unimplemented
 */
BOOLEAN STDCALL
RtlZeroHeap(
    IN PVOID HeapHandle,
    IN ULONG Flags
    )
{
77307190:	55                   	push   %ebp
77307191:	89 e5                	mov    %esp,%ebp
77307193:	50                   	push   %eax
77307194:	50                   	push   %eax
    UNIMPLEMENTED;
77307195:	68 0b 07 00 00       	push   $0x70b
7730719a:	68 52 ab 30 77       	push   $0x7730ab52
7730719f:	68 c5 ab 30 77       	push   $0x7730abc5
773071a4:	68 9c ab 30 77       	push   $0x7730ab9c
773071a9:	e8 d2 07 00 00       	call   77307980 <_DbgPrint>
    return FALSE;
}
773071ae:	31 c0                	xor    %eax,%eax
773071b0:	c9                   	leave  
773071b1:	c2 08 00             	ret    $0x8
773071b4:	90                   	nop    
773071b5:	90                   	nop    
773071b6:	90                   	nop    
773071b7:	90                   	nop    
773071b8:	90                   	nop    
773071b9:	90                   	nop    
773071ba:	90                   	nop    
773071bb:	90                   	nop    
773071bc:	90                   	nop    
773071bd:	90                   	nop    
773071be:	90                   	nop    
773071bf:	90                   	nop    

773071c0 <_RtlDispatchException@8>:
773071c0:	55                   	push   %ebp
773071c1:	89 e5                	mov    %esp,%ebp
773071c3:	50                   	push   %eax
773071c4:	50                   	push   %eax
773071c5:	6a 2a                	push   $0x2a
773071c7:	68 f5 ab 30 77       	push   $0x7730abf5
773071cc:	68 e0 ab 30 77       	push   $0x7730abe0
773071d1:	68 04 ac 30 77       	push   $0x7730ac04
773071d6:	e8 a5 07 00 00       	call   77307980 <_DbgPrint>
773071db:	b8 02 00 00 c0       	mov    $0xc0000002,%eax
773071e0:	c9                   	leave  
773071e1:	c2 08 00             	ret    $0x8
773071e4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
773071ea:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

773071f0 <_RtlGetCallersAddress@8>:
773071f0:	55                   	push   %ebp
773071f1:	89 e5                	mov    %esp,%ebp
773071f3:	52                   	push   %edx
773071f4:	52                   	push   %edx
773071f5:	6a 38                	push   $0x38
773071f7:	68 f5 ab 30 77       	push   $0x7730abf5
773071fc:	68 2d ac 30 77       	push   $0x7730ac2d
77307201:	68 04 ac 30 77       	push   $0x7730ac04
77307206:	e8 75 07 00 00       	call   77307980 <_DbgPrint>
7730720b:	c9                   	leave  
7730720c:	c2 08 00             	ret    $0x8
7730720f:	90                   	nop    

77307210 <_RtlRaiseStatus@4>:
77307210:	55                   	push   %ebp
77307211:	89 e5                	mov    %esp,%ebp
77307213:	83 ec 64             	sub    $0x64,%esp
77307216:	8b 45 08             	mov    0x8(%ebp),%eax
77307219:	c7 45 b0 00 00 00 00 	movl   $0x0,0xffffffb0(%ebp)
77307220:	89 45 a8             	mov    %eax,0xffffffa8(%ebp)
77307223:	8d 45 a8             	lea    0xffffffa8(%ebp),%eax
77307226:	c7 45 b8 00 00 00 00 	movl   $0x0,0xffffffb8(%ebp)
7730722d:	c7 45 ac 01 00 00 00 	movl   $0x1,0xffffffac(%ebp)
77307234:	50                   	push   %eax
77307235:	e8 06 00 00 00       	call   77307240 <_RtlRaiseException@4>
7730723a:	c9                   	leave  
7730723b:	c2 04 00             	ret    $0x4
7730723e:	89 f6                	mov    %esi,%esi

77307240 <_RtlRaiseException@4>:
77307240:	55                   	push   %ebp
77307241:	89 e5                	mov    %esp,%ebp
77307243:	56                   	push   %esi
77307244:	53                   	push   %ebx
77307245:	81 ec dc 02 00 00    	sub    $0x2dc,%esp
7730724b:	8d b5 28 fd ff ff    	lea    0xfffffd28(%ebp),%esi
77307251:	8b 5d 08             	mov    0x8(%ebp),%ebx
77307254:	56                   	push   %esi
77307255:	e8 af 02 00 00       	call   77307509 <_RtlpCaptureContext>
7730725a:	8b 85 dc fd ff ff    	mov    0xfffffddc(%ebp),%eax
77307260:	83 c4 0c             	add    $0xc,%esp
77307263:	8b 40 04             	mov    0x4(%eax),%eax
77307266:	c7 85 28 fd ff ff 07 	movl   $0x10007,0xfffffd28(%ebp)
7730726d:	00 01 00 
77307270:	89 43 0c             	mov    %eax,0xc(%ebx)
77307273:	6a 01                	push   $0x1
77307275:	56                   	push   %esi
77307276:	53                   	push   %ebx
77307277:	e8 d4 07 00 00       	call   77307a50 <_ZwRaiseException@12>
7730727c:	89 c6                	mov    %eax,%esi
7730727e:	51                   	push   %ecx
7730727f:	51                   	push   %ecx
77307280:	53                   	push   %ebx
77307281:	e8 ba ff ff ff       	call   77307240 <_RtlRaiseException@4>
77307286:	56                   	push   %esi
77307287:	e8 84 ff ff ff       	call   77307210 <_RtlRaiseStatus@4>
7730728c:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
7730728f:	5b                   	pop    %ebx
77307290:	5e                   	pop    %esi
77307291:	5d                   	pop    %ebp
77307292:	c2 04 00             	ret    $0x4
77307295:	8d 74 26 00          	lea    0x0(%esi),%esi
77307299:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

773072a0 <_RtlWalkFrameChain@12>:
773072a0:	55                   	push   %ebp
773072a1:	89 e5                	mov    %esp,%ebp
773072a3:	50                   	push   %eax
773072a4:	50                   	push   %eax
773072a5:	6a 6b                	push   $0x6b
773072a7:	68 f5 ab 30 77       	push   $0x7730abf5
773072ac:	68 42 ac 30 77       	push   $0x7730ac42
773072b1:	68 04 ac 30 77       	push   $0x7730ac04
773072b6:	e8 c5 06 00 00       	call   77307980 <_DbgPrint>
773072bb:	31 c0                	xor    %eax,%eax
773072bd:	c9                   	leave  
773072be:	c2 0c 00             	ret    $0xc
773072c1:	90                   	nop    
773072c2:	90                   	nop    
773072c3:	90                   	nop    
773072c4:	90                   	nop    
773072c5:	90                   	nop    
773072c6:	90                   	nop    
773072c7:	90                   	nop    
773072c8:	90                   	nop    
773072c9:	90                   	nop    
773072ca:	90                   	nop    
773072cb:	90                   	nop    
773072cc:	90                   	nop    
773072cd:	90                   	nop    
773072ce:	90                   	nop    
773072cf:	90                   	nop    

773072d0 <_RtlAssert@16>:
773072d0:	55                   	push   %ebp
773072d1:	89 e5                	mov    %esp,%ebp
773072d3:	53                   	push   %ebx
773072d4:	50                   	push   %eax
773072d5:	8b 45 14             	mov    0x14(%ebp),%eax
773072d8:	8b 5d 08             	mov    0x8(%ebp),%ebx
773072db:	8b 4d 0c             	mov    0xc(%ebp),%ecx
773072de:	8b 55 10             	mov    0x10(%ebp),%edx
773072e1:	85 c0                	test   %eax,%eax
773072e3:	74 20                	je     77307305 <_RtlAssert@16+0x35>
773072e5:	83 ec 0c             	sub    $0xc,%esp
773072e8:	50                   	push   %eax
773072e9:	52                   	push   %edx
773072ea:	51                   	push   %ecx
773072eb:	53                   	push   %ebx
773072ec:	68 c0 b2 30 77       	push   $0x7730b2c0
773072f1:	e8 8a 06 00 00       	call   77307980 <_DbgPrint>
773072f6:	83 c4 20             	add    $0x20,%esp
773072f9:	e8 62 07 00 00       	call   77307a60 <_DbgBreakPoint@0>
773072fe:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
77307301:	c9                   	leave  
77307302:	c2 10 00             	ret    $0x10
77307305:	52                   	push   %edx
77307306:	51                   	push   %ecx
77307307:	53                   	push   %ebx
77307308:	68 ec b2 30 77       	push   $0x7730b2ec
7730730d:	e8 6e 06 00 00       	call   77307980 <_DbgPrint>
77307312:	83 c4 10             	add    $0x10,%esp
77307315:	e8 46 07 00 00       	call   77307a60 <_DbgBreakPoint@0>
7730731a:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
7730731d:	c9                   	leave  
7730731e:	c2 10 00             	ret    $0x10
77307321:	eb 0d                	jmp    77307330 <_RtlMapSecurityErrorToNtStatus@4>
77307323:	90                   	nop    
77307324:	90                   	nop    
77307325:	90                   	nop    
77307326:	90                   	nop    
77307327:	90                   	nop    
77307328:	90                   	nop    
77307329:	90                   	nop    
7730732a:	90                   	nop    
7730732b:	90                   	nop    
7730732c:	90                   	nop    
7730732d:	90                   	nop    
7730732e:	90                   	nop    
7730732f:	90                   	nop    

77307330 <_RtlMapSecurityErrorToNtStatus@4>:
77307330:	55                   	push   %ebp
77307331:	89 e5                	mov    %esp,%ebp
77307333:	52                   	push   %edx
77307334:	52                   	push   %edx
77307335:	68 60 03 00 00       	push   $0x360
7730733a:	68 2f b3 30 77       	push   $0x7730b32f
7730733f:	68 11 b3 30 77       	push   $0x7730b311
77307344:	68 38 b3 30 77       	push   $0x7730b338
77307349:	e8 32 06 00 00       	call   77307980 <_DbgPrint>
7730734e:	b8 02 00 00 c0       	mov    $0xc0000002,%eax
77307353:	c9                   	leave  
77307354:	c2 04 00             	ret    $0x4
77307357:	89 f6                	mov    %esi,%esi
77307359:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77307360 <_RtlNtStatusToDosErrorNoTeb@4>:
77307360:	55                   	push   %ebp
77307361:	ba 60 ac 30 77       	mov    $0x7730ac60,%edx
77307366:	89 e5                	mov    %esp,%ebp
77307368:	56                   	push   %esi
77307369:	53                   	push   %ebx
7730736a:	8b 5d 08             	mov    0x8(%ebp),%ebx
7730736d:	85 db                	test   %ebx,%ebx
7730736f:	74 08                	je     77307379 <_RtlNtStatusToDosErrorNoTeb@4+0x19>
77307371:	f7 c3 00 00 00 20    	test   $0x20000000,%ebx
77307377:	74 0b                	je     77307384 <_RtlNtStatusToDosErrorNoTeb@4+0x24>
77307379:	89 d8                	mov    %ebx,%eax
7730737b:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
7730737e:	5b                   	pop    %ebx
7730737f:	5e                   	pop    %esi
77307380:	5d                   	pop    %ebp
77307381:	c2 04 00             	ret    $0x4
77307384:	89 d8                	mov    %ebx,%eax
77307386:	25 00 00 00 f0       	and    $0xf0000000,%eax
7730738b:	3d 00 00 00 d0       	cmp    $0xd0000000,%eax
77307390:	74 41                	je     773073d3 <_RtlNtStatusToDosErrorNoTeb@4+0x73>
77307392:	a1 60 ac 30 77       	mov    0x7730ac60,%eax
77307397:	85 c0                	test   %eax,%eax
77307399:	74 17                	je     773073b2 <_RtlNtStatusToDosErrorNoTeb@4+0x52>
7730739b:	90                   	nop    
7730739c:	8d 74 26 00          	lea    0x0(%esi),%esi
773073a0:	39 c3                	cmp    %eax,%ebx
773073a2:	72 0e                	jb     773073b2 <_RtlNtStatusToDosErrorNoTeb@4+0x52>
773073a4:	3b 5a 04             	cmp    0x4(%edx),%ebx
773073a7:	72 32                	jb     773073db <_RtlNtStatusToDosErrorNoTeb@4+0x7b>
773073a9:	83 c2 0c             	add    $0xc,%edx
773073ac:	8b 02                	mov    (%edx),%eax
773073ae:	85 c0                	test   %eax,%eax
773073b0:	75 ee                	jne    773073a0 <_RtlNtStatusToDosErrorNoTeb@4+0x40>
773073b2:	89 d8                	mov    %ebx,%eax
773073b4:	c1 e8 10             	shr    $0x10,%eax
773073b7:	66 3d 01 c0          	cmp    $0xc001,%ax
773073bb:	74 06                	je     773073c3 <_RtlNtStatusToDosErrorNoTeb@4+0x63>
773073bd:	66 3d 07 80          	cmp    $0x8007,%ax
773073c1:	75 69                	jne    7730742c <_RtlNtStatusToDosErrorNoTeb@4+0xcc>
773073c3:	89 d8                	mov    %ebx,%eax
773073c5:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
773073c8:	25 ff ff 00 00       	and    $0xffff,%eax
773073cd:	5b                   	pop    %ebx
773073ce:	5e                   	pop    %esi
773073cf:	5d                   	pop    %ebp
773073d0:	c2 04 00             	ret    $0x4
773073d3:	81 e3 ff ff ff ef    	and    $0xefffffff,%ebx
773073d9:	eb b7                	jmp    77307392 <_RtlNtStatusToDosErrorNoTeb@4+0x32>
773073db:	89 d9                	mov    %ebx,%ecx
773073dd:	8b 52 08             	mov    0x8(%edx),%edx
773073e0:	29 c1                	sub    %eax,%ecx
773073e2:	66 8b 04 4a          	mov    (%edx,%ecx,2),%ax
773073e6:	89 c6                	mov    %eax,%esi
773073e8:	81 e6 ff ff 00 00    	and    $0xffff,%esi
773073ee:	85 f6                	test   %esi,%esi
773073f0:	75 06                	jne    773073f8 <_RtlNtStatusToDosErrorNoTeb@4+0x98>
773073f2:	89 de                	mov    %ebx,%esi
773073f4:	89 f0                	mov    %esi,%eax
773073f6:	eb 83                	jmp    7730737b <_RtlNtStatusToDosErrorNoTeb@4+0x1b>
773073f8:	81 fe 3d 01 00 00    	cmp    $0x13d,%esi
773073fe:	75 f4                	jne    773073f4 <_RtlNtStatusToDosErrorNoTeb@4+0x94>
77307400:	51                   	push   %ecx
77307401:	68 8f 03 00 00       	push   $0x38f
77307406:	68 2f b3 30 77       	push   $0x7730b32f
7730740b:	68 61 b3 30 77       	push   $0x7730b361
77307410:	e8 6b 05 00 00       	call   77307980 <_DbgPrint>
77307415:	58                   	pop    %eax
77307416:	5a                   	pop    %edx
77307417:	53                   	push   %ebx
77307418:	68 6c b3 30 77       	push   $0x7730b36c
7730741d:	e8 5e 05 00 00       	call   77307980 <_DbgPrint>
77307422:	83 c4 10             	add    $0x10,%esp
77307425:	89 f0                	mov    %esi,%eax
77307427:	e9 4f ff ff ff       	jmp    7730737b <_RtlNtStatusToDosErrorNoTeb@4+0x1b>
7730742c:	51                   	push   %ecx
7730742d:	51                   	push   %ecx
7730742e:	53                   	push   %ebx
7730742f:	68 6c b3 30 77       	push   $0x7730b36c
77307434:	e8 47 05 00 00       	call   77307980 <_DbgPrint>
77307439:	b8 3d 01 00 00       	mov    $0x13d,%eax
7730743e:	e9 38 ff ff ff       	jmp    7730737b <_RtlNtStatusToDosErrorNoTeb@4+0x1b>
77307443:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77307449:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77307450 <_RtlNtStatusToDosError@4>:
77307450:	55                   	push   %ebp
77307451:	89 e5                	mov    %esp,%ebp
77307453:	8b 55 08             	mov    0x8(%ebp),%edx
 struct _TEB * pTeb;

#if defined(__GNUC__)
 /* FIXME: instead of hardcoded offsets, use offsetof() - if possible */
 __asm__ __volatile__
77307456:	64 a1 18 00 00 00    	mov    %fs:0x18,%eax
7730745c:	85 c0                	test   %eax,%eax
7730745e:	74 06                	je     77307466 <_RtlNtStatusToDosError@4+0x16>
77307460:	89 90 f4 0b 00 00    	mov    %edx,0xbf4(%eax)
77307466:	89 55 08             	mov    %edx,0x8(%ebp)
77307469:	c9                   	leave  
7730746a:	e9 f1 fe ff ff       	jmp    77307360 <_RtlNtStatusToDosErrorNoTeb@4>
7730746f:	90                   	nop    

77307470 <_RtlNtStatusToPsxErrno@4>:
77307470:	55                   	push   %ebp
77307471:	83 c8 ff             	or     $0xffffffff,%eax
77307474:	89 e5                	mov    %esp,%ebp
77307476:	5d                   	pop    %ebp
77307477:	c2 04 00             	ret    $0x4
7730747a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

77307480 <_RtlGetLastNtStatus@0>:
77307480:	55                   	push   %ebp
77307481:	89 e5                	mov    %esp,%ebp
 struct _TEB * pTeb;

#if defined(__GNUC__)
 /* FIXME: instead of hardcoded offsets, use offsetof() - if possible */
 __asm__ __volatile__
77307483:	64 a1 18 00 00 00    	mov    %fs:0x18,%eax
77307489:	8b 80 f4 0b 00 00    	mov    0xbf4(%eax),%eax
7730748f:	5d                   	pop    %ebp
77307490:	c3                   	ret    
77307491:	eb 0d                	jmp    773074a0 <_RtlGetLastWin32Error@0>
77307493:	90                   	nop    
77307494:	90                   	nop    
77307495:	90                   	nop    
77307496:	90                   	nop    
77307497:	90                   	nop    
77307498:	90                   	nop    
77307499:	90                   	nop    
7730749a:	90                   	nop    
7730749b:	90                   	nop    
7730749c:	90                   	nop    
7730749d:	90                   	nop    
7730749e:	90                   	nop    
7730749f:	90                   	nop    

773074a0 <_RtlGetLastWin32Error@0>:
773074a0:	55                   	push   %ebp
773074a1:	89 e5                	mov    %esp,%ebp
 struct _TEB * pTeb;

#if defined(__GNUC__)
 /* FIXME: instead of hardcoded offsets, use offsetof() - if possible */
 __asm__ __volatile__
773074a3:	64 a1 18 00 00 00    	mov    %fs:0x18,%eax
773074a9:	8b 40 34             	mov    0x34(%eax),%eax
773074ac:	5d                   	pop    %ebp
773074ad:	c3                   	ret    
773074ae:	89 f6                	mov    %esi,%esi

773074b0 <_RtlSetLastWin32Error@4>:
773074b0:	55                   	push   %ebp
773074b1:	89 e5                	mov    %esp,%ebp
 struct _TEB * pTeb;

#if defined(__GNUC__)
 /* FIXME: instead of hardcoded offsets, use offsetof() - if possible */
 __asm__ __volatile__
773074b3:	64 8b 15 18 00 00 00 	mov    %fs:0x18,%edx
773074ba:	8b 45 08             	mov    0x8(%ebp),%eax
773074bd:	89 42 34             	mov    %eax,0x34(%edx)
773074c0:	5d                   	pop    %ebp
773074c1:	c2 04 00             	ret    $0x4
773074c4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
773074ca:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

773074d0 <_RtlSetLastWin32ErrorAndNtStatusFromNtStatus@4>:
773074d0:	55                   	push   %ebp
773074d1:	89 e5                	mov    %esp,%ebp
773074d3:	53                   	push   %ebx
773074d4:	83 ec 10             	sub    $0x10,%esp
 struct _TEB * pTeb;

#if defined(__GNUC__)
 /* FIXME: instead of hardcoded offsets, use offsetof() - if possible */
 __asm__ __volatile__
773074d7:	64 8b 1d 18 00 00 00 	mov    %fs:0x18,%ebx
773074de:	8b 45 08             	mov    0x8(%ebp),%eax
773074e1:	50                   	push   %eax
773074e2:	e8 69 ff ff ff       	call   77307450 <_RtlNtStatusToDosError@4>
773074e7:	89 43 34             	mov    %eax,0x34(%ebx)
773074ea:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
773074ed:	c9                   	leave  
773074ee:	c2 04 00             	ret    $0x4
773074f1:	90                   	nop    
773074f2:	90                   	nop    
773074f3:	90                   	nop    
773074f4:	90                   	nop    
773074f5:	90                   	nop    
773074f6:	90                   	nop    
773074f7:	90                   	nop    
773074f8:	90                   	nop    
773074f9:	90                   	nop    
773074fa:	90                   	nop    
773074fb:	90                   	nop    
773074fc:	90                   	nop    
773074fd:	90                   	nop    
773074fe:	90                   	nop    
773074ff:	90                   	nop    

77307500 <_do_debug>:
77307500:	60                   	pusha  
77307501:	50                   	push   %eax
77307502:	e8 49 01 00 00       	call   77307650 <_AsmDebug@4>
77307507:	61                   	popa   
77307508:	c3                   	ret    

77307509 <_RtlpCaptureContext>:
77307509:	55                   	push   %ebp
7730750a:	89 e5                	mov    %esp,%ebp
7730750c:	53                   	push   %ebx
7730750d:	8b 55 08             	mov    0x8(%ebp),%edx
77307510:	fc                   	cld    
77307511:	9c                   	pushf  
77307512:	58                   	pop    %eax
77307513:	89 82 c0 00 00 00    	mov    %eax,0xc0(%edx)
77307519:	31 c0                	xor    %eax,%eax
7730751b:	89 82 b0 00 00 00    	mov    %eax,0xb0(%edx)
77307521:	89 82 a4 00 00 00    	mov    %eax,0xa4(%edx)
77307527:	89 82 ac 00 00 00    	mov    %eax,0xac(%edx)
7730752d:	89 82 a8 00 00 00    	mov    %eax,0xa8(%edx)
77307533:	89 82 a0 00 00 00    	mov    %eax,0xa0(%edx)
77307539:	89 82 9c 00 00 00    	mov    %eax,0x9c(%edx)
7730753f:	8c c8                	mov    %cs,%eax
77307541:	89 82 bc 00 00 00    	mov    %eax,0xbc(%edx)
77307547:	8c d8                	mov    %ds,%eax
77307549:	89 82 98 00 00 00    	mov    %eax,0x98(%edx)
7730754f:	8c c0                	mov    %es,%eax
77307551:	89 82 94 00 00 00    	mov    %eax,0x94(%edx)
77307557:	8c e0                	mov    %fs,%eax
77307559:	89 82 90 00 00 00    	mov    %eax,0x90(%edx)
7730755f:	8c e8                	mov    %gs,%eax
77307561:	89 82 8c 00 00 00    	mov    %eax,0x8c(%edx)
77307567:	8c d0                	mov    %ss,%eax
77307569:	89 82 c8 00 00 00    	mov    %eax,0xc8(%edx)
7730756f:	89 eb                	mov    %ebp,%ebx
77307571:	8b 1b                	mov    (%ebx),%ebx
77307573:	8b 43 04             	mov    0x4(%ebx),%eax
77307576:	8b 1b                	mov    (%ebx),%ebx
77307578:	89 82 b8 00 00 00    	mov    %eax,0xb8(%edx)
7730757e:	89 9a b4 00 00 00    	mov    %ebx,0xb4(%edx)
77307584:	83 c3 08             	add    $0x8,%ebx
77307587:	89 9a c4 00 00 00    	mov    %ebx,0xc4(%edx)
7730758d:	5b                   	pop    %ebx
7730758e:	89 ec                	mov    %ebp,%esp
77307590:	5d                   	pop    %ebp
77307591:	c3                   	ret    

77307592 <_RtlpExecuteHandler>:
77307592:	55                   	push   %ebp
77307593:	89 e5                	mov    %esp,%ebp
77307595:	ff 75 0c             	pushl  0xc(%ebp)
77307598:	52                   	push   %edx
77307599:	64 ff 35 00 00 00 00 	pushl  %fs:0x0
773075a0:	64 89 25 00 00 00 00 	mov    %esp,%fs:0x0
773075a7:	ff 75 14             	pushl  0x14(%ebp)
773075aa:	ff 75 10             	pushl  0x10(%ebp)
773075ad:	ff 75 0c             	pushl  0xc(%ebp)
773075b0:	ff 75 08             	pushl  0x8(%ebp)
773075b3:	8b 45 18             	mov    0x18(%ebp),%eax
773075b6:	ff d0                	call   *%eax
773075b8:	64 83 3d 00 00 00 00 	cmpl   $0xffffffff,%fs:0x0
773075bf:	ff 
773075c0:	75 1f                	jne    773075e1 <.reh_stack_looks_ok>
773075c2:	ff 35 00 00 00 00    	pushl  0x0
773075c8:	ff 35 00 00 00 00    	pushl  0x0
773075ce:	ff 35 00 00 00 00    	pushl  0x0
773075d4:	ff 35 00 00 00 00    	pushl  0x0
773075da:	e8 f1 fc ff ff       	call   773072d0 <_RtlAssert@16>

773075df <.reh_loop>:
773075df:	eb fe                	jmp    773075df <.reh_loop>

773075e1 <.reh_stack_looks_ok>:
773075e1:	64 8b 25 00 00 00 00 	mov    %fs:0x0,%esp
773075e8:	64 8f 05 00 00 00 00 	popl   %fs:0x0
773075ef:	89 ec                	mov    %ebp,%esp
773075f1:	5d                   	pop    %ebp
773075f2:	c3                   	ret    

773075f3 <_RtlpExceptionProtector>:
773075f3:	b8 01 00 00 00       	mov    $0x1,%eax
773075f8:	8b 4c 24 04          	mov    0x4(%esp),%ecx
773075fc:	f7 41 04 02 00 00 00 	testl  $0x2,0x4(%ecx)
77307603:	75 0f                	jne    77307614 <.rep_end>
77307605:	8b 4c 24 10          	mov    0x10(%esp),%ecx
77307609:	8b 44 24 08          	mov    0x8(%esp),%eax
7730760d:	89 01                	mov    %eax,(%ecx)
7730760f:	b8 02 00 00 00       	mov    $0x2,%eax

77307614 <.rep_end>:
77307614:	c3                   	ret    

77307615 <_RtlpExecuteHandlerForException>:
77307615:	ba f3 75 30 77       	mov    $0x773075f3,%edx
7730761a:	e9 73 ff ff ff       	jmp    77307592 <_RtlpExecuteHandler>

7730761f <_RtlpUnwindProtector>:
7730761f:	b8 01 00 00 00       	mov    $0x1,%eax
77307624:	89 4c 24 04          	mov    %ecx,0x4(%esp)
77307628:	f7 41 04 02 00 00 00 	testl  $0x2,0x4(%ecx)
7730762f:	74 12                	je     77307643 <.rup_end>
77307631:	8b 4c 24 08          	mov    0x8(%esp),%ecx
77307635:	8b 54 24 10          	mov    0x10(%esp),%edx
77307639:	8b 41 08             	mov    0x8(%ecx),%eax
7730763c:	89 02                	mov    %eax,(%edx)
7730763e:	b8 03 00 00 00       	mov    $0x3,%eax

77307643 <.rup_end>:
77307643:	c3                   	ret    

77307644 <_RtlpExecuteHandlerForUnwind>:
77307644:	ba 1f 76 30 77       	mov    $0x7730761f,%edx
77307649:	e9 44 ff ff ff       	jmp    77307592 <_RtlpExecuteHandler>
7730764e:	90                   	nop    
7730764f:	90                   	nop    

77307650 <_AsmDebug@4>:
77307650:	55                   	push   %ebp
77307651:	89 e5                	mov    %esp,%ebp
77307653:	83 ec 10             	sub    $0x10,%esp
77307656:	8b 45 08             	mov    0x8(%ebp),%eax
77307659:	50                   	push   %eax
7730765a:	68 c0 b3 30 77       	push   $0x7730b3c0
7730765f:	e8 1c 03 00 00       	call   77307980 <_DbgPrint>
77307664:	c9                   	leave  
77307665:	c2 04 00             	ret    $0x4
77307668:	90                   	nop    
77307669:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

77307670 <_RtlpDispatchException>:
77307670:	55                   	push   %ebp
77307671:	89 e5                	mov    %esp,%ebp
77307673:	57                   	push   %edi
77307674:	56                   	push   %esi
77307675:	53                   	push   %ebx
77307676:	83 ec 6c             	sub    $0x6c,%esp
77307679:	31 ff                	xor    %edi,%edi
7730767b:	8b 75 08             	mov    0x8(%ebp),%esi
 struct _TEB * pTeb;

#if defined(__GNUC__)
 /* FIXME: instead of hardcoded offsets, use offsetof() - if possible */
 __asm__ __volatile__
7730767e:	64 a1 18 00 00 00    	mov    %fs:0x18,%eax
77307684:	8b 18                	mov    (%eax),%ebx
    }

    if (ReturnValue == ExceptionContinueExecution)
    {
      DPRINT("ReturnValue == ExceptionContinueExecution\n");
      if (ExceptionRecord->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
      {
        DPRINT("(ExceptionRecord->ExceptionFlags & EXCEPTION_NONCONTINUABLE) == TRUE\n");

        ExceptionRecord2.ExceptionRecord = ExceptionRecord;
        ExceptionRecord2.ExceptionCode = STATUS_NONCONTINUABLE_EXCEPTION;
        ExceptionRecord2.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
        ExceptionRecord2.NumberParameters = 0;
        RtlRaiseException(&ExceptionRecord2);
      }
      else
      {
        /* Copy the (possibly changed) context back to the trap frame and return */
        ZwContinue(Context, FALSE);
        return ExceptionContinueExecution;
      }
    }
    else if (ReturnValue == ExceptionContinueSearch)
    {
      DPRINT("ReturnValue == ExceptionContinueSearch\n");

      /* Nothing to do here */
    }
    else if (ReturnValue == ExceptionNestedException)
    {
      DPRINT("ReturnValue == ExceptionNestedException\n");

      ExceptionRecord->ExceptionFlags |= EXCEPTION_NESTED_CALL;
      if (NestedFrame < DispatcherContext)
	  {
          NestedFrame = DispatcherContext;
	  }
    }
    else /* if (ReturnValue == ExceptionCollidedUnwind) */
    {
      DPRINT("ReturnValue == ExceptionCollidedUnwind or unknown\n");

      ExceptionRecord2.ExceptionRecord = ExceptionRecord;
      ExceptionRecord2.ExceptionCode = STATUS_INVALID_DISPOSITION;
      ExceptionRecord2.ExceptionFlags = EXCEPTION_NONCONTINUABLE;
      ExceptionRecord2.NumberParameters = 0;
      RtlRaiseException(&ExceptionRecord2);
    }

    RegistrationFrame = RegistrationFrame->prev;  // Go to previous frame
77307686:	83 fb ff             	cmp    $0xffffffff,%ebx
77307689:	74 5a                	je     773076e5 <_RtlpDispatchException+0x75>
7730768b:	90                   	nop    
7730768c:	8d 74 26 00          	lea    0x0(%esi),%esi
77307690:	83 ec 0c             	sub    $0xc,%esp
77307693:	8b 43 04             	mov    0x4(%ebx),%eax
77307696:	50                   	push   %eax
77307697:	8d 45 94             	lea    0xffffff94(%ebp),%eax
7730769a:	50                   	push   %eax
7730769b:	8b 45 0c             	mov    0xc(%ebp),%eax
7730769e:	50                   	push   %eax
7730769f:	53                   	push   %ebx
773076a0:	56                   	push   %esi
773076a1:	e8 6f ff ff ff       	call   77307615 <_RtlpExecuteHandlerForException>
773076a6:	83 c4 20             	add    $0x20,%esp
773076a9:	39 fb                	cmp    %edi,%ebx
773076ab:	74 75                	je     77307722 <_RtlpDispatchException+0xb2>
773076ad:	85 c0                	test   %eax,%eax
773076af:	75 45                	jne    773076f6 <_RtlpDispatchException+0x86>
773076b1:	f6 46 04 01          	testb  $0x1,0x4(%esi)
773076b5:	74 7b                	je     77307732 <_RtlpDispatchException+0xc2>
773076b7:	89 75 a0             	mov    %esi,0xffffffa0(%ebp)
773076ba:	c7 45 98 25 00 00 c0 	movl   $0xc0000025,0xffffff98(%ebp)
773076c1:	83 ec 0c             	sub    $0xc,%esp
773076c4:	c7 45 9c 01 00 00 00 	movl   $0x1,0xffffff9c(%ebp)
773076cb:	c7 45 a8 00 00 00 00 	movl   $0x0,0xffffffa8(%ebp)
773076d2:	8d 45 98             	lea    0xffffff98(%ebp),%eax
773076d5:	50                   	push   %eax
773076d6:	e8 65 fb ff ff       	call   77307240 <_RtlRaiseException@4>
773076db:	83 c4 0c             	add    $0xc,%esp
773076de:	8b 1b                	mov    (%ebx),%ebx
773076e0:	83 fb ff             	cmp    $0xffffffff,%ebx
773076e3:	75 ab                	jne    77307690 <_RtlpDispatchException+0x20>
  }
 
  /* No exception handler will handle this exception */

  DPRINT("RtlpDispatchException(): Return ExceptionContinueExecution\n");

  ExceptionRecord->ExceptionFlags = EXCEPTION_NONCONTINUABLE;
773076e5:	c7 46 04 01 00 00 00 	movl   $0x1,0x4(%esi)

  return ExceptionContinueExecution;  
}
773076ec:	31 c0                	xor    %eax,%eax
773076ee:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
773076f1:	5b                   	pop    %ebx
773076f2:	5e                   	pop    %esi
773076f3:	5f                   	pop    %edi
773076f4:	5d                   	pop    %ebp
773076f5:	c3                   	ret    
773076f6:	83 f8 01             	cmp    $0x1,%eax
773076f9:	74 e3                	je     773076de <_RtlpDispatchException+0x6e>
773076fb:	83 f8 02             	cmp    $0x2,%eax
773076fe:	75 16                	jne    77307716 <_RtlpDispatchException+0xa6>
77307700:	8b 56 04             	mov    0x4(%esi),%edx
77307703:	8b 45 94             	mov    0xffffff94(%ebp),%eax
77307706:	83 ca 10             	or     $0x10,%edx
77307709:	39 c7                	cmp    %eax,%edi
7730770b:	89 56 04             	mov    %edx,0x4(%esi)
7730770e:	73 ce                	jae    773076de <_RtlpDispatchException+0x6e>
77307710:	89 c7                	mov    %eax,%edi
77307712:	8b 1b                	mov    (%ebx),%ebx
77307714:	eb ca                	jmp    773076e0 <_RtlpDispatchException+0x70>
77307716:	89 75 a0             	mov    %esi,0xffffffa0(%ebp)
77307719:	c7 45 98 26 00 00 c0 	movl   $0xc0000026,0xffffff98(%ebp)
77307720:	eb 9f                	jmp    773076c1 <_RtlpDispatchException+0x51>
77307722:	8b 7e 04             	mov    0x4(%esi),%edi
77307725:	83 e7 ef             	and    $0xffffffef,%edi
77307728:	89 7e 04             	mov    %edi,0x4(%esi)
7730772b:	31 ff                	xor    %edi,%edi
7730772d:	e9 7b ff ff ff       	jmp    773076ad <_RtlpDispatchException+0x3d>
77307732:	53                   	push   %ebx
77307733:	53                   	push   %ebx
77307734:	6a 00                	push   $0x0
77307736:	8b 4d 0c             	mov    0xc(%ebp),%ecx
77307739:	51                   	push   %ecx
7730773a:	e8 31 03 00 00       	call   77307a70 <_ZwContinue@8>
7730773f:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77307742:	31 c0                	xor    %eax,%eax
77307744:	5b                   	pop    %ebx
77307745:	5e                   	pop    %esi
77307746:	5f                   	pop    %edi
77307747:	5d                   	pop    %ebp
77307748:	c3                   	ret    
77307749:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

77307750 <_RtlUnwind@16>:


/*
 * @implemented
 */
VOID STDCALL
RtlUnwind(PEXCEPTION_REGISTRATION RegistrationFrame,
  PVOID ReturnAddress,
  PEXCEPTION_RECORD ExceptionRecord,
  DWORD EaxValue)
{
77307750:	55                   	push   %ebp
77307751:	89 e5                	mov    %esp,%ebp
77307753:	57                   	push   %edi
77307754:	56                   	push   %esi
77307755:	53                   	push   %ebx
77307756:	81 ec 8c 03 00 00    	sub    $0x38c,%esp
7730775c:	8b 7d 08             	mov    0x8(%ebp),%edi
 struct _TEB * pTeb;

#if defined(__GNUC__)
 /* FIXME: instead of hardcoded offsets, use offsetof() - if possible */
 __asm__ __volatile__
7730775f:	64 a1 18 00 00 00    	mov    %fs:0x18,%eax
  PEXCEPTION_REGISTRATION ERHead;
  PEXCEPTION_RECORD pExceptRec;
  EXCEPTION_RECORD TempER;    
  CONTEXT Context;

  DPRINT("RtlUnwind(). RegistrationFrame 0x%X\n", RegistrationFrame);

#ifndef NDEBUG
  RtlpDumpExceptionRegistrations();
#endif /* NDEBUG */

  ERHead = SehpGetExceptionList();
 
  DPRINT("ERHead is 0x%X\n", ERHead);

  if (ExceptionRecord == NULL) // The normal case
  {
	DPRINT("ExceptionRecord == NULL (normal)\n");

    pExceptRec = &TempER;
    pExceptRec->ExceptionFlags = 0;
    pExceptRec->ExceptionCode = STATUS_UNWIND;
    pExceptRec->ExceptionRecord = NULL;
    pExceptRec->ExceptionAddress = ReturnAddress;
    pExceptRec->ExceptionInformation[0] = 0;
  }
  else
  {
    pExceptRec = ExceptionRecord;
77307765:	8b 75 10             	mov    0x10(%ebp),%esi

#if defined(_M_IX86)
/* on the x86, the TEB is contained in the FS segment */
static inline struct _TEB * NtCurrentTeb(void)
{
77307768:	8b 18                	mov    (%eax),%ebx
7730776a:	85 f6                	test   %esi,%esi
7730776c:	0f 84 3b 01 00 00    	je     773078ad <_RtlUnwind@16+0x15d>
  }

  if (RegistrationFrame)
77307772:	85 ff                	test   %edi,%edi
77307774:	0f 84 28 01 00 00    	je     773078a2 <_RtlUnwind@16+0x152>
    pExceptRec->ExceptionFlags |= EXCEPTION_UNWINDING;
7730777a:	8b 46 04             	mov    0x4(%esi),%eax
7730777d:	83 c8 02             	or     $0x2,%eax
  else
    pExceptRec->ExceptionFlags |= (EXCEPTION_UNWINDING|EXCEPTION_EXIT_UNWIND);

#ifndef NDEBUG
  DPRINT("ExceptionFlags == 0x%x:\n", pExceptRec->ExceptionFlags);
  if (pExceptRec->ExceptionFlags & EXCEPTION_UNWINDING)
  {
	  DPRINT("  * EXCEPTION_UNWINDING (0x%x)\n", EXCEPTION_UNWINDING);
  }
  if (pExceptRec->ExceptionFlags & EXCEPTION_EXIT_UNWIND)
  {
	  DPRINT("  * EXCEPTION_EXIT_UNWIND (0x%x)\n", EXCEPTION_EXIT_UNWIND);
  }
#endif /* NDEBUG */

  Context.ContextFlags =
    (CONTEXT_i386 | CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS);

  RtlpCaptureContext(&Context);
77307780:	83 ec 0c             	sub    $0xc,%esp
77307783:	89 46 04             	mov    %eax,0x4(%esi)
77307786:	8d 85 c8 fc ff ff    	lea    0xfffffcc8(%ebp),%eax
7730778c:	c7 85 c8 fc ff ff 07 	movl   $0x10007,0xfffffcc8(%ebp)
77307793:	00 01 00 
77307796:	50                   	push   %eax
77307797:	e8 6d fd ff ff       	call   77307509 <_RtlpCaptureContext>

  DPRINT("Context.Eip = 0x%.08x\n", Context.Eip);
  DPRINT("Context.Ebp = 0x%.08x\n", Context.Ebp);
  DPRINT("Context.Esp = 0x%.08x\n", Context.Esp);

  Context.Esp += 0x10;
7730779c:	8b 85 8c fd ff ff    	mov    0xfffffd8c(%ebp),%eax
  Context.Eax = EaxValue;
 
  // Begin traversing the list of EXCEPTION_REGISTRATION
  while ((ULONG_PTR)ERHead != -1 && ERHead != RegistrationFrame)
773077a2:	83 c4 10             	add    $0x10,%esp
773077a5:	83 c0 10             	add    $0x10,%eax
773077a8:	89 85 8c fd ff ff    	mov    %eax,0xfffffd8c(%ebp)
773077ae:	8b 45 14             	mov    0x14(%ebp),%eax
773077b1:	89 85 78 fd ff ff    	mov    %eax,0xfffffd78(%ebp)
773077b7:	eb 47                	jmp    77307800 <_RtlUnwind@16+0xb0>
773077b9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
  {
    EXCEPTION_RECORD er2;
 
    DPRINT("ERHead 0x%X\n", ERHead);

    // If there's an exception frame, but it's lower on the stack
    // than the head of the exception list, something's wrong!
    if (RegistrationFrame && (RegistrationFrame <= ERHead))
    {
      DPRINT("The exception frame is bad\n");

      // Generate an exception to bail out
      er2.ExceptionRecord = pExceptRec;
      er2.NumberParameters = 0;
      er2.ExceptionCode = STATUS_INVALID_UNWIND_TARGET;
      er2.ExceptionFlags = EXCEPTION_NONCONTINUABLE;    
 
      RtlRaiseException(&er2);
    }
 
#if 0
    Stack = ERHead + sizeof(EXCEPTION_REGISTRATION);
    if ( (Teb->Tib.StackBase <= (PVOID)ERHead )      // Make sure that ERHead
      && (Teb->Tib.->StackLimit >= (PVOID)Stack )      // is in range, and a multiple
      && (0 == ((ULONG_PTR)ERHead & 3)) )         // of 4 (i.e., sane)
#else
    if (1)
#endif
    {
      PEXCEPTION_REGISTRATION NewERHead;
      PEXCEPTION_REGISTRATION pCurrExceptReg;
      EXCEPTION_DISPOSITION ReturnValue;
  
      DPRINT("Executing handler at 0x%X for unwind\n", ERHead->handler);

      ReturnValue = RtlpExecuteHandlerForUnwind(
        pExceptRec,
        ERHead,
        &Context,
        &NewERHead,
        ERHead->handler);
 
      DPRINT("Handler at 0x%X returned 0x%X\n", ERHead->handler, ReturnValue);

      if (ReturnValue != ExceptionContinueSearch)
      {
        if (ReturnValue != ExceptionCollidedUnwind)
        {
          DPRINT("Bad return value\n");

          er2.ExceptionRecord = pExceptRec;
          er2.NumberParameters = 0;
          er2.ExceptionCode = STATUS_INVALID_DISPOSITION;
          er2.ExceptionFlags = EXCEPTION_NONCONTINUABLE;    
 
          RtlRaiseException(&er2);
773077c0:	83 ec 0c             	sub    $0xc,%esp
773077c3:	8d 85 78 fc ff ff    	lea    0xfffffc78(%ebp),%eax
773077c9:	89 b5 80 fc ff ff    	mov    %esi,0xfffffc80(%ebp)
773077cf:	c7 85 88 fc ff ff 00 	movl   $0x0,0xfffffc88(%ebp)
773077d6:	00 00 00 
773077d9:	c7 85 78 fc ff ff 26 	movl   $0xc0000026,0xfffffc78(%ebp)
773077e0:	00 00 c0 
773077e3:	c7 85 7c fc ff ff 01 	movl   $0x1,0xfffffc7c(%ebp)
773077ea:	00 00 00 
773077ed:	50                   	push   %eax
773077ee:	e8 4d fa ff ff       	call   77307240 <_RtlRaiseException@4>
773077f3:	83 c4 0c             	add    $0xc,%esp
        }
        else
        {
          ERHead = NewERHead;
        }
      }
 
      pCurrExceptReg = ERHead;
      ERHead = ERHead->prev;
773077f6:	8b 1b                	mov    (%ebx),%ebx
 struct _TEB * pTeb;

#if defined(__GNUC__)
 /* FIXME: instead of hardcoded offsets, use offsetof() - if possible */
 __asm__ __volatile__
773077f8:	64 a1 18 00 00 00    	mov    %fs:0x18,%eax
773077fe:	89 18                	mov    %ebx,(%eax)
77307800:	83 fb ff             	cmp    $0xffffffff,%ebx
77307803:	0f 95 c2             	setne  %dl
77307806:	39 fb                	cmp    %edi,%ebx
77307808:	0f 95 c0             	setne  %al
7730780b:	25 ff 00 00 00       	and    $0xff,%eax
77307810:	85 c2                	test   %eax,%edx
77307812:	0f 84 80 00 00 00    	je     77307898 <_RtlUnwind@16+0x148>
77307818:	85 ff                	test   %edi,%edi
7730781a:	0f 95 c2             	setne  %dl
7730781d:	39 df                	cmp    %ebx,%edi
7730781f:	0f 96 c0             	setbe  %al
77307822:	25 ff 00 00 00       	and    $0xff,%eax
77307827:	85 c2                	test   %eax,%edx
77307829:	75 35                	jne    77307860 <_RtlUnwind@16+0x110>
7730782b:	83 ec 0c             	sub    $0xc,%esp
7730782e:	8b 43 04             	mov    0x4(%ebx),%eax
77307831:	50                   	push   %eax
77307832:	8d 85 74 fc ff ff    	lea    0xfffffc74(%ebp),%eax
77307838:	50                   	push   %eax
77307839:	8d 85 c8 fc ff ff    	lea    0xfffffcc8(%ebp),%eax
7730783f:	50                   	push   %eax
77307840:	53                   	push   %ebx
77307841:	56                   	push   %esi
77307842:	e8 fd fd ff ff       	call   77307644 <_RtlpExecuteHandlerForUnwind>
77307847:	83 c4 20             	add    $0x20,%esp
7730784a:	83 f8 01             	cmp    $0x1,%eax
7730784d:	74 a7                	je     773077f6 <_RtlUnwind@16+0xa6>
7730784f:	83 f8 03             	cmp    $0x3,%eax
77307852:	0f 85 68 ff ff ff    	jne    773077c0 <_RtlUnwind@16+0x70>
77307858:	8b 9d 74 fc ff ff    	mov    0xfffffc74(%ebp),%ebx
7730785e:	eb 96                	jmp    773077f6 <_RtlUnwind@16+0xa6>
77307860:	83 ec 0c             	sub    $0xc,%esp
77307863:	8d 85 78 fc ff ff    	lea    0xfffffc78(%ebp),%eax
77307869:	89 b5 80 fc ff ff    	mov    %esi,0xfffffc80(%ebp)
7730786f:	c7 85 88 fc ff ff 00 	movl   $0x0,0xfffffc88(%ebp)
77307876:	00 00 00 
77307879:	c7 85 78 fc ff ff 29 	movl   $0xc0000029,0xfffffc78(%ebp)
77307880:	00 00 c0 
77307883:	c7 85 7c fc ff ff 01 	movl   $0x1,0xfffffc7c(%ebp)
7730788a:	00 00 00 
7730788d:	50                   	push   %eax
7730788e:	e8 ad f9 ff ff       	call   77307240 <_RtlRaiseException@4>
77307893:	83 c4 0c             	add    $0xc,%esp
77307896:	eb 93                	jmp    7730782b <_RtlUnwind@16+0xdb>

#if defined(_M_IX86)
/* on the x86, the TEB is contained in the FS segment */
static inline struct _TEB * NtCurrentTeb(void)
{
77307898:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
7730789b:	5b                   	pop    %ebx
7730789c:	5e                   	pop    %esi
7730789d:	5f                   	pop    %edi
7730789e:	5d                   	pop    %ebp
7730789f:	c2 10 00             	ret    $0x10
773078a2:	8b 46 04             	mov    0x4(%esi),%eax
773078a5:	83 c8 06             	or     $0x6,%eax
773078a8:	e9 d3 fe ff ff       	jmp    77307780 <_RtlUnwind@16+0x30>
773078ad:	8b 45 0c             	mov    0xc(%ebp),%eax
773078b0:	8d 75 98             	lea    0xffffff98(%ebp),%esi
773078b3:	c7 45 9c 00 00 00 00 	movl   $0x0,0xffffff9c(%ebp)
773078ba:	c7 45 98 27 00 00 c0 	movl   $0xc0000027,0xffffff98(%ebp)
773078c1:	c7 45 a0 00 00 00 00 	movl   $0x0,0xffffffa0(%ebp)
773078c8:	89 45 a4             	mov    %eax,0xffffffa4(%ebp)
773078cb:	c7 45 ac 00 00 00 00 	movl   $0x0,0xffffffac(%ebp)
773078d2:	e9 9b fe ff ff       	jmp    77307772 <_RtlUnwind@16+0x22>
773078d7:	90                   	nop    
773078d8:	90                   	nop    
773078d9:	90                   	nop    
773078da:	90                   	nop    
773078db:	90                   	nop    
773078dc:	90                   	nop    
773078dd:	90                   	nop    
773078de:	90                   	nop    
773078df:	90                   	nop    

773078e0 <_inet_ntoa@4>:
773078e0:	ff 25 4c e2 30 77    	jmp    *0x7730e24c
773078e6:	90                   	nop    
773078e7:	90                   	nop    
	...

773078f0 <_inet_addr@4>:
773078f0:	ff 25 48 e2 30 77    	jmp    *0x7730e248
773078f6:	90                   	nop    
773078f7:	90                   	nop    
	...

77307900 <_RtlInitUnicodeString@8>:
77307900:	ff 25 f8 e1 30 77    	jmp    *0x7730e1f8
77307906:	90                   	nop    
77307907:	90                   	nop    
	...

77307910 <_ZwCreateFile@44>:
77307910:	ff 25 0c e2 30 77    	jmp    *0x7730e20c
77307916:	90                   	nop    
77307917:	90                   	nop    
	...

77307920 <_NtClose@4>:
77307920:	ff 25 ec e1 30 77    	jmp    *0x7730e1ec
77307926:	90                   	nop    
77307927:	90                   	nop    
	...

77307930 <_memcpy>:
77307930:	ff 25 1c e2 30 77    	jmp    *0x7730e21c
77307936:	90                   	nop    
77307937:	90                   	nop    
	...

77307940 <_strncpy>:
77307940:	ff 25 34 e2 30 77    	jmp    *0x7730e234
77307946:	90                   	nop    
77307947:	90                   	nop    
	...

77307950 <_strcpy>:
77307950:	ff 25 2c e2 30 77    	jmp    *0x7730e22c
77307956:	90                   	nop    
77307957:	90                   	nop    
	...

77307960 <_strlen>:
77307960:	ff 25 30 e2 30 77    	jmp    *0x7730e230
77307966:	90                   	nop    
77307967:	90                   	nop    
	...

77307970 <_strcmp>:
77307970:	ff 25 28 e2 30 77    	jmp    *0x7730e228
77307976:	90                   	nop    
77307977:	90                   	nop    
	...

77307980 <_DbgPrint>:
77307980:	ff 25 e4 e1 30 77    	jmp    *0x7730e1e4
77307986:	90                   	nop    
77307987:	90                   	nop    
	...

77307990 <_memset>:
77307990:	ff 25 20 e2 30 77    	jmp    *0x7730e220
77307996:	90                   	nop    
77307997:	90                   	nop    
	...

773079a0 <_strtoul>:
773079a0:	ff 25 38 e2 30 77    	jmp    *0x7730e238
773079a6:	90                   	nop    
773079a7:	90                   	nop    
	...

773079b0 <__strnicmp>:
773079b0:	ff 25 18 e2 30 77    	jmp    *0x7730e218
773079b6:	90                   	nop    
773079b7:	90                   	nop    
	...

773079c0 <_qsort>:
773079c0:	ff 25 24 e2 30 77    	jmp    *0x7730e224
773079c6:	90                   	nop    
773079c7:	90                   	nop    
	...

773079d0 <_wcslen>:
773079d0:	ff 25 3c e2 30 77    	jmp    *0x7730e23c
773079d6:	90                   	nop    
773079d7:	90                   	nop    
	...

773079e0 <_ZwFreeVirtualMemory@16>:
773079e0:	ff 25 10 e2 30 77    	jmp    *0x7730e210
773079e6:	90                   	nop    
773079e7:	90                   	nop    
	...

773079f0 <_ZwAllocateVirtualMemory@24>:
773079f0:	ff 25 04 e2 30 77    	jmp    *0x7730e204
773079f6:	90                   	nop    
773079f7:	90                   	nop    
	...

77307a00 <_RtlInitializeCriticalSection@4>:
77307a00:	ff 25 fc e1 30 77    	jmp    *0x7730e1fc
77307a06:	90                   	nop    
77307a07:	90                   	nop    
	...

77307a10 <_NtAllocateVirtualMemory@24>:
77307a10:	ff 25 e8 e1 30 77    	jmp    *0x7730e1e8
77307a16:	90                   	nop    
77307a17:	90                   	nop    
	...

77307a20 <_RtlLeaveCriticalSection@4>:
77307a20:	ff 25 00 e2 30 77    	jmp    *0x7730e200
77307a26:	90                   	nop    
77307a27:	90                   	nop    
	...

77307a30 <_RtlEnterCriticalSection@4>:
77307a30:	ff 25 f4 e1 30 77    	jmp    *0x7730e1f4
77307a36:	90                   	nop    
77307a37:	90                   	nop    
	...

77307a40 <_RtlDeleteCriticalSection@4>:
77307a40:	ff 25 f0 e1 30 77    	jmp    *0x7730e1f0
77307a46:	90                   	nop    
77307a47:	90                   	nop    
	...

77307a50 <_ZwRaiseException@12>:
77307a50:	ff 25 14 e2 30 77    	jmp    *0x7730e214
77307a56:	90                   	nop    
77307a57:	90                   	nop    
	...

77307a60 <_DbgBreakPoint@0>:
77307a60:	ff 25 e0 e1 30 77    	jmp    *0x7730e1e0
77307a66:	90                   	nop    
77307a67:	90                   	nop    
	...

77307a70 <_ZwContinue@8>:
77307a70:	ff 25 08 e2 30 77    	jmp    *0x7730e208
77307a76:	90                   	nop    
77307a77:	90                   	nop    
	...

77307a80 <___do_global_dtors>:
77307a80:	55                   	push   %ebp
77307a81:	89 e5                	mov    %esp,%ebp
77307a83:	83 ec 08             	sub    $0x8,%esp
77307a86:	a1 00 90 30 77       	mov    0x77309000,%eax
77307a8b:	8b 08                	mov    (%eax),%ecx
77307a8d:	85 c9                	test   %ecx,%ecx
77307a8f:	74 26                	je     77307ab7 <___do_global_dtors+0x37>
77307a91:	eb 0d                	jmp    77307aa0 <___do_global_dtors+0x20>
77307a93:	90                   	nop    
77307a94:	90                   	nop    
77307a95:	90                   	nop    
77307a96:	90                   	nop    
77307a97:	90                   	nop    
77307a98:	90                   	nop    
77307a99:	90                   	nop    
77307a9a:	90                   	nop    
77307a9b:	90                   	nop    
77307a9c:	90                   	nop    
77307a9d:	90                   	nop    
77307a9e:	90                   	nop    
77307a9f:	90                   	nop    
77307aa0:	ff 10                	call   *(%eax)
77307aa2:	8b 0d 00 90 30 77    	mov    0x77309000,%ecx
77307aa8:	8b 51 04             	mov    0x4(%ecx),%edx
77307aab:	8d 41 04             	lea    0x4(%ecx),%eax
77307aae:	a3 00 90 30 77       	mov    %eax,0x77309000
77307ab3:	85 d2                	test   %edx,%edx
77307ab5:	75 e9                	jne    77307aa0 <___do_global_dtors+0x20>
77307ab7:	c9                   	leave  
77307ab8:	c3                   	ret    
77307ab9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

77307ac0 <___do_global_ctors>:
77307ac0:	55                   	push   %ebp
77307ac1:	89 e5                	mov    %esp,%ebp
77307ac3:	53                   	push   %ebx
77307ac4:	83 ec 04             	sub    $0x4,%esp
77307ac7:	a1 00 80 30 77       	mov    0x77308000,%eax
77307acc:	83 f8 ff             	cmp    $0xffffffff,%eax
77307acf:	74 29                	je     77307afa <___do_global_ctors+0x3a>
77307ad1:	85 c0                	test   %eax,%eax
77307ad3:	89 c3                	mov    %eax,%ebx
77307ad5:	74 13                	je     77307aea <___do_global_ctors+0x2a>
77307ad7:	89 f6                	mov    %esi,%esi
77307ad9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi
77307ae0:	ff 14 9d 00 80 30 77 	call   *0x77308000(,%ebx,4)
77307ae7:	4b                   	dec    %ebx
77307ae8:	75 f6                	jne    77307ae0 <___do_global_ctors+0x20>
77307aea:	c7 04 24 80 7a 30 77 	movl   $0x77307a80,(%esp)
77307af1:	e8 6a 96 ff ff       	call   77301160 <_atexit>
77307af6:	5b                   	pop    %ebx
77307af7:	5b                   	pop    %ebx
77307af8:	5d                   	pop    %ebp
77307af9:	c3                   	ret    
77307afa:	8b 0d 04 80 30 77    	mov    0x77308004,%ecx
77307b00:	31 c0                	xor    %eax,%eax
77307b02:	85 c9                	test   %ecx,%ecx
77307b04:	eb 0a                	jmp    77307b10 <___do_global_ctors+0x50>
77307b06:	40                   	inc    %eax
77307b07:	8b 14 85 04 80 30 77 	mov    0x77308004(,%eax,4),%edx
77307b0e:	85 d2                	test   %edx,%edx
77307b10:	75 f4                	jne    77307b06 <___do_global_ctors+0x46>
77307b12:	eb bd                	jmp    77307ad1 <___do_global_ctors+0x11>
77307b14:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77307b1a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

77307b20 <___main>:
77307b20:	55                   	push   %ebp
77307b21:	89 e5                	mov    %esp,%ebp
77307b23:	53                   	push   %ebx
77307b24:	83 ec 04             	sub    $0x4,%esp
77307b27:	a1 70 c0 30 77       	mov    0x7730c070,%eax
77307b2c:	85 c0                	test   %eax,%eax
77307b2e:	75 36                	jne    77307b66 <___main+0x46>
77307b30:	a1 00 80 30 77       	mov    0x77308000,%eax
77307b35:	bb 01 00 00 00       	mov    $0x1,%ebx
77307b3a:	89 1d 70 c0 30 77    	mov    %ebx,0x7730c070
77307b40:	83 f8 ff             	cmp    $0xffffffff,%eax
77307b43:	74 25                	je     77307b6a <___main+0x4a>
77307b45:	85 c0                	test   %eax,%eax
77307b47:	89 c3                	mov    %eax,%ebx
77307b49:	74 0f                	je     77307b5a <___main+0x3a>
77307b4b:	90                   	nop    
77307b4c:	8d 74 26 00          	lea    0x0(%esi),%esi
77307b50:	ff 14 9d 00 80 30 77 	call   *0x77308000(,%ebx,4)
77307b57:	4b                   	dec    %ebx
77307b58:	75 f6                	jne    77307b50 <___main+0x30>
77307b5a:	c7 04 24 80 7a 30 77 	movl   $0x77307a80,(%esp)
77307b61:	e8 fa 95 ff ff       	call   77301160 <_atexit>
77307b66:	5b                   	pop    %ebx
77307b67:	5b                   	pop    %ebx
77307b68:	5d                   	pop    %ebp
77307b69:	c3                   	ret    
77307b6a:	8b 0d 04 80 30 77    	mov    0x77308004,%ecx
77307b70:	31 c0                	xor    %eax,%eax
77307b72:	85 c9                	test   %ecx,%ecx
77307b74:	eb 0a                	jmp    77307b80 <___main+0x60>
77307b76:	40                   	inc    %eax
77307b77:	8b 14 85 04 80 30 77 	mov    0x77308004(,%eax,4),%edx
77307b7e:	85 d2                	test   %edx,%edx
77307b80:	75 f4                	jne    77307b76 <___main+0x56>
77307b82:	eb c1                	jmp    77307b45 <___main+0x25>
77307b84:	90                   	nop    
77307b85:	90                   	nop    
77307b86:	90                   	nop    
77307b87:	90                   	nop    
77307b88:	90                   	nop    
77307b89:	90                   	nop    
77307b8a:	90                   	nop    
77307b8b:	90                   	nop    
77307b8c:	90                   	nop    
77307b8d:	90                   	nop    
77307b8e:	90                   	nop    
77307b8f:	90                   	nop    

77307b90 <__pei386_runtime_relocator>:
77307b90:	55                   	push   %ebp
77307b91:	b9 b0 b4 30 77       	mov    $0x7730b4b0,%ecx
77307b96:	89 e5                	mov    %esp,%ebp
77307b98:	eb 14                	jmp    77307bae <__pei386_runtime_relocator+0x1e>
77307b9a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
77307ba0:	8b 51 04             	mov    0x4(%ecx),%edx
77307ba3:	8b 01                	mov    (%ecx),%eax
77307ba5:	83 c1 08             	add    $0x8,%ecx
77307ba8:	01 82 00 00 30 77    	add    %eax,0x77300000(%edx)
77307bae:	81 f9 b0 b4 30 77    	cmp    $0x7730b4b0,%ecx
77307bb4:	72 ea                	jb     77307ba0 <__pei386_runtime_relocator+0x10>
77307bb6:	5d                   	pop    %ebp
77307bb7:	c3                   	ret    
77307bb8:	90                   	nop    
77307bb9:	90                   	nop    
77307bba:	90                   	nop    
77307bbb:	90                   	nop    
77307bbc:	90                   	nop    
77307bbd:	90                   	nop    
77307bbe:	90                   	nop    
77307bbf:	90                   	nop    

77307bc0 <___w32_sharedptr_default_unexpected>:
77307bc0:	55                   	push   %ebp
77307bc1:	a1 c0 c0 30 77       	mov    0x7730c0c0,%eax
77307bc6:	89 e5                	mov    %esp,%ebp
77307bc8:	5d                   	pop    %ebp
77307bc9:	8b 48 04             	mov    0x4(%eax),%ecx
77307bcc:	ff e1                	jmp    *%ecx
77307bce:	89 f6                	mov    %esi,%esi

77307bd0 <___w32_sharedptr_get>:
77307bd0:	55                   	push   %ebp
77307bd1:	ba 42 00 00 00       	mov    $0x42,%edx
77307bd6:	89 e5                	mov    %esp,%ebp
77307bd8:	53                   	push   %ebx
77307bd9:	0f b7 c0             	movzwl %ax,%eax
77307bdc:	83 ec 64             	sub    $0x64,%esp
77307bdf:	89 54 24 08          	mov    %edx,0x8(%esp)
77307be3:	8d 55 a8             	lea    0xffffffa8(%ebp),%edx
77307be6:	31 db                	xor    %ebx,%ebx
77307be8:	89 54 24 04          	mov    %edx,0x4(%esp)
77307bec:	89 04 24             	mov    %eax,(%esp)
77307bef:	ff 15 60 e2 30 77    	call   *0x7730e260
77307bf5:	ba 1f 00 00 00       	mov    $0x1f,%edx
77307bfa:	b9 01 00 00 00       	mov    $0x1,%ecx
77307bff:	83 ec 0c             	sub    $0xc,%esp
77307c02:	85 c0                	test   %eax,%eax
77307c04:	75 07                	jne    77307c0d <___w32_sharedptr_get+0x3d>
77307c06:	eb 46                	jmp    77307c4e <___w32_sharedptr_get+0x7e>
77307c08:	01 c9                	add    %ecx,%ecx
77307c0a:	4a                   	dec    %edx
77307c0b:	78 0e                	js     77307c1b <___w32_sharedptr_get+0x4b>
77307c0d:	80 7c 2a a8 41       	cmpb   $0x41,0xffffffa8(%edx,%ebp,1)
77307c12:	75 f4                	jne    77307c08 <___w32_sharedptr_get+0x38>
77307c14:	09 cb                	or     %ecx,%ebx
77307c16:	01 c9                	add    %ecx,%ecx
77307c18:	4a                   	dec    %edx
77307c19:	79 f2                	jns    77307c0d <___w32_sharedptr_get+0x3d>
77307c1b:	83 3b 3c             	cmpl   $0x3c,(%ebx)
77307c1e:	75 07                	jne    77307c27 <___w32_sharedptr_get+0x57>
77307c20:	89 d8                	mov    %ebx,%eax
77307c22:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
77307c25:	c9                   	leave  
77307c26:	c3                   	ret    
77307c27:	b9 f4 b3 30 77       	mov    $0x7730b3f4,%ecx
77307c2c:	ba ea 00 00 00       	mov    $0xea,%edx
77307c31:	89 4c 24 0c          	mov    %ecx,0xc(%esp)
77307c35:	89 54 24 08          	mov    %edx,0x8(%esp)
77307c39:	c7 04 24 21 b4 30 77 	movl   $0x7730b421,(%esp)
77307c40:	b8 40 b4 30 77       	mov    $0x7730b440,%eax
77307c45:	89 44 24 04          	mov    %eax,0x4(%esp)
77307c49:	e8 62 02 00 00       	call   77307eb0 <___eprintf>
77307c4e:	b8 6c b4 30 77       	mov    $0x7730b46c,%eax
77307c53:	bb e4 00 00 00       	mov    $0xe4,%ebx
77307c58:	89 44 24 0c          	mov    %eax,0xc(%esp)
77307c5c:	89 5c 24 08          	mov    %ebx,0x8(%esp)
77307c60:	eb d7                	jmp    77307c39 <___w32_sharedptr_get+0x69>
77307c62:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
77307c69:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

77307c70 <___w32_sharedptr_initialize>:
77307c70:	55                   	push   %ebp
77307c71:	89 e5                	mov    %esp,%ebp
77307c73:	57                   	push   %edi
77307c74:	56                   	push   %esi
77307c75:	53                   	push   %ebx
77307c76:	81 ec cc 00 00 00    	sub    $0xcc,%esp
77307c7c:	8b 0d c0 c0 30 77    	mov    0x7730c0c0,%ecx
77307c82:	85 c9                	test   %ecx,%ecx
77307c84:	74 08                	je     77307c8e <___w32_sharedptr_initialize+0x1e>
77307c86:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77307c89:	5b                   	pop    %ebx
77307c8a:	5e                   	pop    %esi
77307c8b:	5f                   	pop    %edi
77307c8c:	5d                   	pop    %ebp
77307c8d:	c3                   	ret    
77307c8e:	c7 45 98 41 41 41 41 	movl   $0x41414141,0xffffff98(%ebp)
77307c95:	a1 d0 b3 30 77       	mov    0x7730b3d0,%eax
77307c9a:	8d 75 98             	lea    0xffffff98(%ebp),%esi
77307c9d:	c7 45 9c 41 41 41 41 	movl   $0x41414141,0xffffff9c(%ebp)
77307ca4:	c7 45 a0 41 41 41 41 	movl   $0x41414141,0xffffffa0(%ebp)
77307cab:	89 45 b8             	mov    %eax,0xffffffb8(%ebp)
77307cae:	a1 d4 b3 30 77       	mov    0x7730b3d4,%eax
77307cb3:	c7 45 a4 41 41 41 41 	movl   $0x41414141,0xffffffa4(%ebp)
77307cba:	c7 45 a8 41 41 41 41 	movl   $0x41414141,0xffffffa8(%ebp)
77307cc1:	89 45 bc             	mov    %eax,0xffffffbc(%ebp)
77307cc4:	a1 d8 b3 30 77       	mov    0x7730b3d8,%eax
77307cc9:	c7 45 ac 41 41 41 41 	movl   $0x41414141,0xffffffac(%ebp)
77307cd0:	c7 45 b0 41 41 41 41 	movl   $0x41414141,0xffffffb0(%ebp)
77307cd7:	89 45 c0             	mov    %eax,0xffffffc0(%ebp)
77307cda:	a1 dc b3 30 77       	mov    0x7730b3dc,%eax
77307cdf:	c7 45 b4 41 41 41 41 	movl   $0x41414141,0xffffffb4(%ebp)
77307ce6:	89 45 c4             	mov    %eax,0xffffffc4(%ebp)
77307ce9:	a1 e0 b3 30 77       	mov    0x7730b3e0,%eax
77307cee:	89 45 c8             	mov    %eax,0xffffffc8(%ebp)
77307cf1:	a1 e4 b3 30 77       	mov    0x7730b3e4,%eax
77307cf6:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
77307cf9:	a1 e8 b3 30 77       	mov    0x7730b3e8,%eax
77307cfe:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
77307d01:	a1 ec b3 30 77       	mov    0x7730b3ec,%eax
77307d06:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
77307d09:	0f b7 05 f0 b3 30 77 	movzwl 0x7730b3f0,%eax
77307d10:	66 89 45 d8          	mov    %ax,0xffffffd8(%ebp)
77307d14:	89 34 24             	mov    %esi,(%esp)
77307d17:	ff 15 5c e2 30 77    	call   *0x7730e25c
77307d1d:	0f b7 c0             	movzwl %ax,%eax
77307d20:	83 ec 04             	sub    $0x4,%esp
77307d23:	85 c0                	test   %eax,%eax
77307d25:	89 85 44 ff ff ff    	mov    %eax,0xffffff44(%ebp)
77307d2b:	0f 85 3b 01 00 00    	jne    77307e6c <___w32_sharedptr_initialize+0x1fc>
77307d31:	c7 04 24 3c 00 00 00 	movl   $0x3c,(%esp)
77307d38:	e8 03 02 00 00       	call   77307f40 <_malloc>
77307d3d:	85 c0                	test   %eax,%eax
77307d3f:	89 c3                	mov    %eax,%ebx
77307d41:	0f 84 59 01 00 00    	je     77307ea0 <___w32_sharedptr_initialize+0x230>
77307d47:	fc                   	cld    
77307d48:	89 c7                	mov    %eax,%edi
77307d4a:	8b 85 44 ff ff ff    	mov    0xffffff44(%ebp),%eax
77307d50:	b9 0f 00 00 00       	mov    $0xf,%ecx
77307d55:	f3 ab                	repz stos %eax,%es:(%edi)
77307d57:	c7 43 04 b0 7f 30 77 	movl   $0x77307fb0,0x4(%ebx)
77307d5e:	b9 01 00 00 00       	mov    $0x1,%ecx
77307d63:	c7 43 08 c0 7b 30 77 	movl   $0x77307bc0,0x8(%ebx)
77307d6a:	a1 90 c0 30 77       	mov    0x7730c090,%eax
77307d6f:	c7 03 3c 00 00 00    	movl   $0x3c,(%ebx)
77307d75:	8b 15 94 c0 30 77    	mov    0x7730c094,%edx
77307d7b:	c7 43 28 00 00 00 00 	movl   $0x0,0x28(%ebx)
77307d82:	89 43 14             	mov    %eax,0x14(%ebx)
77307d85:	a1 10 90 30 77       	mov    0x77309010,%eax
77307d8a:	89 53 18             	mov    %edx,0x18(%ebx)
77307d8d:	8b 15 14 90 30 77    	mov    0x77309014,%edx
77307d93:	89 43 1c             	mov    %eax,0x1c(%ebx)
77307d96:	a1 a0 c0 30 77       	mov    0x7730c0a0,%eax
77307d9b:	89 53 20             	mov    %edx,0x20(%ebx)
77307d9e:	c7 43 30 ff ff ff ff 	movl   $0xffffffff,0x30(%ebx)
77307da5:	89 43 2c             	mov    %eax,0x2c(%ebx)
77307da8:	8b 15 1c 90 30 77    	mov    0x7730901c,%edx
77307dae:	a1 18 90 30 77       	mov    0x77309018,%eax
77307db3:	89 53 38             	mov    %edx,0x38(%ebx)
77307db6:	ba 1f 00 00 00       	mov    $0x1f,%edx
77307dbb:	89 43 34             	mov    %eax,0x34(%ebx)
77307dbe:	89 f6                	mov    %esi,%esi
77307dc0:	89 d8                	mov    %ebx,%eax
77307dc2:	21 c8                	and    %ecx,%eax
77307dc4:	83 f8 01             	cmp    $0x1,%eax
77307dc7:	19 c0                	sbb    %eax,%eax
77307dc9:	24 20                	and    $0x20,%al
77307dcb:	01 c9                	add    %ecx,%ecx
77307dcd:	04 41                	add    $0x41,%al
77307dcf:	88 84 2a 48 ff ff ff 	mov    %al,0xffffff48(%edx,%ebp,1)
77307dd6:	4a                   	dec    %edx
77307dd7:	79 e7                	jns    77307dc0 <___w32_sharedptr_initialize+0x150>
77307dd9:	a1 d0 b3 30 77       	mov    0x7730b3d0,%eax
77307dde:	89 85 68 ff ff ff    	mov    %eax,0xffffff68(%ebp)
77307de4:	a1 d4 b3 30 77       	mov    0x7730b3d4,%eax
77307de9:	89 85 6c ff ff ff    	mov    %eax,0xffffff6c(%ebp)
77307def:	a1 d8 b3 30 77       	mov    0x7730b3d8,%eax
77307df4:	89 85 70 ff ff ff    	mov    %eax,0xffffff70(%ebp)
77307dfa:	a1 dc b3 30 77       	mov    0x7730b3dc,%eax
77307dff:	89 85 74 ff ff ff    	mov    %eax,0xffffff74(%ebp)
77307e05:	a1 e0 b3 30 77       	mov    0x7730b3e0,%eax
77307e0a:	89 85 78 ff ff ff    	mov    %eax,0xffffff78(%ebp)
77307e10:	a1 e4 b3 30 77       	mov    0x7730b3e4,%eax
77307e15:	89 85 7c ff ff ff    	mov    %eax,0xffffff7c(%ebp)
77307e1b:	a1 e8 b3 30 77       	mov    0x7730b3e8,%eax
77307e20:	89 45 80             	mov    %eax,0xffffff80(%ebp)
77307e23:	a1 ec b3 30 77       	mov    0x7730b3ec,%eax
77307e28:	89 45 84             	mov    %eax,0xffffff84(%ebp)
77307e2b:	0f b7 05 f0 b3 30 77 	movzwl 0x7730b3f0,%eax
77307e32:	66 89 45 88          	mov    %ax,0xffffff88(%ebp)
77307e36:	8d 85 48 ff ff ff    	lea    0xffffff48(%ebp),%eax
77307e3c:	89 04 24             	mov    %eax,(%esp)
77307e3f:	ff 15 58 e2 30 77    	call   *0x7730e258
77307e45:	0f b7 f8             	movzwl %ax,%edi
77307e48:	83 ec 04             	sub    $0x4,%esp
77307e4b:	85 ff                	test   %edi,%edi
77307e4d:	75 42                	jne    77307e91 <___w32_sharedptr_initialize+0x221>
77307e4f:	31 d2                	xor    %edx,%edx
77307e51:	85 d2                	test   %edx,%edx
77307e53:	75 1e                	jne    77307e73 <___w32_sharedptr_initialize+0x203>
77307e55:	89 1c 24             	mov    %ebx,(%esp)
77307e58:	e8 c3 00 00 00       	call   77307f20 <_free>
77307e5d:	89 34 24             	mov    %esi,(%esp)
77307e60:	ff 15 5c e2 30 77    	call   *0x7730e25c
77307e66:	83 ec 04             	sub    $0x4,%esp
77307e69:	0f b7 c0             	movzwl %ax,%eax
77307e6c:	e8 5f fd ff ff       	call   77307bd0 <___w32_sharedptr_get>
77307e71:	89 c3                	mov    %eax,%ebx
77307e73:	89 1d c0 c0 30 77    	mov    %ebx,0x7730c0c0
77307e79:	8d 43 04             	lea    0x4(%ebx),%eax
77307e7c:	a3 b0 c0 30 77       	mov    %eax,0x7730c0b0
77307e81:	8d 43 08             	lea    0x8(%ebx),%eax
77307e84:	a3 d0 c0 30 77       	mov    %eax,0x7730c0d0
77307e89:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
77307e8c:	5b                   	pop    %ebx
77307e8d:	5e                   	pop    %esi
77307e8e:	5f                   	pop    %edi
77307e8f:	5d                   	pop    %ebp
77307e90:	c3                   	ret    
77307e91:	89 f8                	mov    %edi,%eax
77307e93:	e8 38 fd ff ff       	call   77307bd0 <___w32_sharedptr_get>
77307e98:	39 d8                	cmp    %ebx,%eax
77307e9a:	89 fa                	mov    %edi,%edx
77307e9c:	75 b1                	jne    77307e4f <___w32_sharedptr_initialize+0x1df>
77307e9e:	eb b1                	jmp    77307e51 <___w32_sharedptr_initialize+0x1e1>
77307ea0:	e8 0b 01 00 00       	call   77307fb0 <_abort>
77307ea5:	90                   	nop    
77307ea6:	90                   	nop    
77307ea7:	90                   	nop    
77307ea8:	90                   	nop    
77307ea9:	90                   	nop    
77307eaa:	90                   	nop    
77307eab:	90                   	nop    
77307eac:	90                   	nop    
77307ead:	90                   	nop    
77307eae:	90                   	nop    
77307eaf:	90                   	nop    

77307eb0 <___eprintf>:
77307eb0:	55                   	push   %ebp
77307eb1:	89 e5                	mov    %esp,%ebp
77307eb3:	83 ec 18             	sub    $0x18,%esp
77307eb6:	8b 45 14             	mov    0x14(%ebp),%eax
77307eb9:	89 44 24 10          	mov    %eax,0x10(%esp)
77307ebd:	8b 45 10             	mov    0x10(%ebp),%eax
77307ec0:	89 44 24 0c          	mov    %eax,0xc(%esp)
77307ec4:	8b 45 0c             	mov    0xc(%ebp),%eax
77307ec7:	89 44 24 08          	mov    %eax,0x8(%esp)
77307ecb:	8b 45 08             	mov    0x8(%ebp),%eax
77307ece:	89 44 24 04          	mov    %eax,0x4(%esp)
77307ed2:	a1 74 e2 30 77       	mov    0x7730e274,%eax
77307ed7:	83 c0 40             	add    $0x40,%eax
77307eda:	89 04 24             	mov    %eax,(%esp)
77307edd:	e8 8e 00 00 00       	call   77307f70 <_fprintf>
77307ee2:	a1 74 e2 30 77       	mov    0x7730e274,%eax
77307ee7:	83 c0 40             	add    $0x40,%eax
77307eea:	89 04 24             	mov    %eax,(%esp)
77307eed:	e8 1e 00 00 00       	call   77307f10 <_fflush>
77307ef2:	e8 b9 00 00 00       	call   77307fb0 <_abort>
77307ef7:	90                   	nop    
77307ef8:	90                   	nop    
77307ef9:	90                   	nop    
77307efa:	90                   	nop    
77307efb:	90                   	nop    
77307efc:	90                   	nop    
77307efd:	90                   	nop    
77307efe:	90                   	nop    
77307eff:	90                   	nop    

77307f00 <___dllonexit>:
77307f00:	ff 25 6c e2 30 77    	jmp    *0x7730e26c
77307f06:	90                   	nop    
77307f07:	90                   	nop    
	...

77307f10 <_fflush>:
77307f10:	ff 25 84 e2 30 77    	jmp    *0x7730e284
77307f16:	90                   	nop    
77307f17:	90                   	nop    
	...

77307f20 <_free>:
77307f20:	ff 25 98 e2 30 77    	jmp    *0x7730e298
77307f26:	90                   	nop    
77307f27:	90                   	nop    
	...

77307f30 <__errno>:
77307f30:	ff 25 70 e2 30 77    	jmp    *0x7730e270
77307f36:	90                   	nop    
77307f37:	90                   	nop    
	...

77307f40 <_malloc>:
77307f40:	ff 25 9c e2 30 77    	jmp    *0x7730e29c
77307f46:	90                   	nop    
77307f47:	90                   	nop    
	...

77307f50 <_calloc>:
77307f50:	ff 25 7c e2 30 77    	jmp    *0x7730e27c
77307f56:	90                   	nop    
77307f57:	90                   	nop    
	...

77307f60 <_fputc>:
77307f60:	ff 25 94 e2 30 77    	jmp    *0x7730e294
77307f66:	90                   	nop    
77307f67:	90                   	nop    
	...

77307f70 <_fprintf>:
77307f70:	ff 25 90 e2 30 77    	jmp    *0x7730e290
77307f76:	90                   	nop    
77307f77:	90                   	nop    
	...

77307f80 <_fclose>:
77307f80:	ff 25 80 e2 30 77    	jmp    *0x7730e280
77307f86:	90                   	nop    
77307f87:	90                   	nop    
	...

77307f90 <_fgets>:
77307f90:	ff 25 88 e2 30 77    	jmp    *0x7730e288
77307f96:	90                   	nop    
77307f97:	90                   	nop    
	...

77307fa0 <_fopen>:
77307fa0:	ff 25 8c e2 30 77    	jmp    *0x7730e28c
77307fa6:	90                   	nop    
77307fa7:	90                   	nop    
	...

77307fb0 <_abort>:
77307fb0:	ff 25 78 e2 30 77    	jmp    *0x7730e278
77307fb6:	90                   	nop    
77307fb7:	90                   	nop    
	...

77307fc0 <_GetAtomNameA@12>:
77307fc0:	ff 25 60 e2 30 77    	jmp    *0x7730e260
77307fc6:	90                   	nop    
77307fc7:	90                   	nop    
	...

77307fd0 <_FindAtomA@4>:
77307fd0:	ff 25 5c e2 30 77    	jmp    *0x7730e25c
77307fd6:	90                   	nop    
77307fd7:	90                   	nop    
	...

77307fe0 <_AddAtomA@4>:
77307fe0:	ff 25 58 e2 30 77    	jmp    *0x7730e258
77307fe6:	90                   	nop    
77307fe7:	90                   	nop    
	...

77307ff0 <___sjlj_init_ctor>:
77307ff0:	55                   	push   %ebp
77307ff1:	89 e5                	mov    %esp,%ebp
77307ff3:	5d                   	pop    %ebp
77307ff4:	e9 c7 91 ff ff       	jmp    773011c0 <___do_sjlj_init>
77307ff9:	90                   	nop    
77307ffa:	90                   	nop    
77307ffb:	90                   	nop    
77307ffc:	90                   	nop    
77307ffd:	90                   	nop    
77307ffe:	90                   	nop    
77307fff:	90                   	nop    

77308000 <__CTOR_LIST__>:
77308000:	ff                   	(bad)  
77308001:	ff                   	(bad)  
77308002:	ff                   	(bad)  
77308003:	ff f0                	push   %eax

77308004 <.ctors>:
77308004:	f0 7f 30             	lock jg 77308037 <__DTOR_LIST__+0x2b>
77308007:	77 00                	ja     77308009 <.ctors+0x5>
77308009:	00 00                	add    %al,(%eax)
	...

7730800c <__DTOR_LIST__>:
7730800c:	ff                   	(bad)  
7730800d:	ff                   	(bad)  
7730800e:	ff                   	(bad)  
7730800f:	ff 00                	incl   (%eax)
77308011:	00 00                	add    %al,(%eax)
	...
