
aclui.nostrip.dll:     file format pei-i386

Disassembly of section .text:

71551000 <_IID_ISecurityObjectTypeInfo>:
71551000:	eb 66                	jmp    71551068 <_SecurityPageCallback@12+0x28>
71551002:	30 fc                	xor    %bh,%ah
71551004:	ef                   	out    %eax,(%dx)
71551005:	79 4b                	jns    71551052 <_SecurityPageCallback@12+0x12>
71551007:	44                   	inc    %esp
71551008:	91                   	xchg   %eax,%ecx
71551009:	11 d1                	adc    %edx,%ecx
7155100b:	8a 75 eb             	mov    0xffffffeb(%ebp),%dh
7155100e:	f2 fa                	repnz cli 

71551010 <_IID_IEffectivePermission>:
71551010:	76 dc                	jbe    71550fee <__image_base__+0xfee>
71551012:	53                   	push   %ebx
71551013:	38 35 9f 7c 40 88    	cmp    %dh,0x88407c9f
71551019:	a1 d1 93 44 36       	mov    0x364493d1,%eax
7155101e:	5f                   	pop    %edi
7155101f:	bc b4 fd cc c3       	mov    $0xc3ccfdb4,%esp

71551020 <_IID_ISecurityInformation2>:
71551020:	b4 fd                	mov    $0xfd,%ah
71551022:	cc                   	int3   
71551023:	c3                   	ret    
71551024:	88 6f d2             	mov    %ch,0xffffffd2(%edi)
71551027:	11 a3 ce 00 c0 4f    	adc    %esp,0x4fc000ce(%ebx)
7155102d:	b1 78                	mov    $0x78,%cl
7155102f:	2a 60 c3             	sub    0xffffffc3(%eax),%ah

71551030 <_IID_ISecurityInformation>:
71551030:	60                   	pusha  
71551031:	c3                   	ret    
71551032:	5f                   	pop    %edi
71551033:	96                   	xchg   %eax,%esi
71551034:	ff 16                	call   *(%esi)
71551036:	d0 11                	rclb   (%ecx)
71551038:	91                   	xchg   %eax,%ecx
71551039:	cb                   	lret   
7155103a:	00 aa 00 bb b7 23    	add    %ch,0x23b7bb00(%edx)

71551040 <_SecurityPageCallback@12>:
HINSTANCE hDllInstance;

UINT CALLBACK
SecurityPageCallback(HWND hwnd, UINT uMsg, LPPROPSHEETPAGE ppsp)
{
71551040:	55                   	push   %ebp
71551041:	89 e5                	mov    %esp,%ebp
71551043:	53                   	push   %ebx
71551044:	50                   	push   %eax
71551045:	8b 55 0c             	mov    0xc(%ebp),%edx
71551048:	8b 5d 10             	mov    0x10(%ebp),%ebx
  switch(uMsg)
7155104b:	83 fa 01             	cmp    $0x1,%edx
7155104e:	74 10                	je     71551060 <_SecurityPageCallback@12+0x20>
  {
    case PSPCB_CREATE:
    {
      PSECURITY_PAGE sp;

      sp = LocalAlloc(LHND, sizeof(SECURITY_PAGE));
      if(sp != NULL)
      {
        /* save the pointer to the ISecurityInformation interface */
        sp->psi = (LPSECURITYINFO)ppsp->lParam;
        /* set the lParam to the allocated structure */
        ppsp->lParam = (LPARAM)sp;
        return TRUE;
      }
      return FALSE;
    }
    case PSPCB_RELEASE:
    {
      if(ppsp->lParam != 0)
      {
        PSECURITY_PAGE sp = (PSECURITY_PAGE)ppsp->lParam;
        if(sp->hiUsrs != NULL)
        {
          ImageList_Destroy(sp->hiUsrs);
        }
        LocalFree((HLOCAL)sp);
      }
      return FALSE;
    }
  }

  return FALSE;
71551050:	31 c0                	xor    %eax,%eax
71551052:	83 fa 02             	cmp    $0x2,%edx
71551055:	74 2c                	je     71551083 <_SecurityPageCallback@12+0x43>
}
71551057:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
7155105a:	c9                   	leave  
7155105b:	c2 0c 00             	ret    $0xc
7155105e:	89 f6                	mov    %esi,%esi
71551060:	8b 5b 1c             	mov    0x1c(%ebx),%ebx
71551063:	85 db                	test   %ebx,%ebx
71551065:	74 13                	je     7155107a <_SecurityPageCallback@12+0x3a>
71551067:	8b 43 08             	mov    0x8(%ebx),%eax
7155106a:	85 c0                	test   %eax,%eax
7155106c:	75 3a                	jne    715510a8 <_SecurityPageCallback@12+0x68>
7155106e:	83 ec 0c             	sub    $0xc,%esp
71551071:	53                   	push   %ebx
71551072:	e8 c9 05 00 00       	call   71551640 <_LocalFree@4>
71551077:	83 c4 0c             	add    $0xc,%esp
7155107a:	31 c0                	xor    %eax,%eax
7155107c:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
7155107f:	c9                   	leave  
71551080:	c2 0c 00             	ret    $0xc
71551083:	50                   	push   %eax
71551084:	50                   	push   %eax
71551085:	6a 10                	push   $0x10
71551087:	6a 42                	push   $0x42
71551089:	e8 c2 05 00 00       	call   71551650 <_LocalAlloc@8>
7155108e:	89 c2                	mov    %eax,%edx
71551090:	58                   	pop    %eax
71551091:	31 c0                	xor    %eax,%eax
71551093:	59                   	pop    %ecx
71551094:	85 d2                	test   %edx,%edx
71551096:	74 bf                	je     71551057 <_SecurityPageCallback@12+0x17>
71551098:	8b 43 1c             	mov    0x1c(%ebx),%eax
7155109b:	89 53 1c             	mov    %edx,0x1c(%ebx)
7155109e:	89 42 0c             	mov    %eax,0xc(%edx)
715510a1:	b8 01 00 00 00       	mov    $0x1,%eax
715510a6:	eb af                	jmp    71551057 <_SecurityPageCallback@12+0x17>
715510a8:	83 ec 0c             	sub    $0xc,%esp
715510ab:	50                   	push   %eax
715510ac:	e8 0f 06 00 00       	call   715516c0 <_ImageList_Destroy@4>
715510b1:	83 c4 0c             	add    $0xc,%esp
715510b4:	eb b8                	jmp    7155106e <_SecurityPageCallback@12+0x2e>
715510b6:	8d 76 00             	lea    0x0(%esi),%esi
715510b9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

715510c0 <_SecurityPageProc@16>:


INT_PTR CALLBACK
SecurityPageProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
715510c0:	55                   	push   %ebp
715510c1:	89 e5                	mov    %esp,%ebp
715510c3:	56                   	push   %esi
715510c4:	53                   	push   %ebx
715510c5:	83 ec 30             	sub    $0x30,%esp
715510c8:	8b 75 08             	mov    0x8(%ebp),%esi
715510cb:	8b 5d 14             	mov    0x14(%ebp),%ebx
  PSECURITY_PAGE sp;
  
  switch(uMsg)
715510ce:	81 7d 0c 10 01 00 00 	cmpl   $0x110,0xc(%ebp)
715510d5:	74 0b                	je     715510e2 <_SecurityPageProc@16+0x22>
  {
    case WM_INITDIALOG:
    {
      sp = (PSECURITY_PAGE)lParam;
      if(sp != NULL)
      {
        LV_COLUMN lvc;
        RECT rcLvClient;
        
        sp->hWnd = hwndDlg;
        sp->hWndUsrList = GetDlgItem(hwndDlg, IDC_ACELIST);
        sp->hiUsrs = ImageList_LoadBitmap(hDllInstance, MAKEINTRESOURCE(IDB_USRGRPIMAGES), 16, 3, 0);
        
        /* save the pointer to the structure */
        SetWindowLongPtr(hwndDlg, DWL_USER, (DWORD_PTR)sp);
        
        GetClientRect(sp->hWndUsrList, &rcLvClient);
        
        /* setup the listview control */
        ListView_SetExtendedListViewStyleEx(sp->hWndUsrList, LVS_EX_FULLROWSELECT, LVS_EX_FULLROWSELECT);
        ListView_SetImageList(sp->hWndUsrList, sp->hiUsrs, LVSIL_SMALL);

        /* add a column to the list view */
        lvc.mask = LVCF_FMT | LVCF_WIDTH;
        lvc.fmt = LVCFMT_LEFT;
        lvc.cx = rcLvClient.right;
        ListView_InsertColumn(sp->hWndUsrList, 0, &lvc);
        
        /* FIXME - hide controls in case the flags aren't present */
      }
      break;
    }
  }
  return 0;
}
715510d7:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
715510da:	31 c0                	xor    %eax,%eax
715510dc:	5b                   	pop    %ebx
715510dd:	5e                   	pop    %esi
715510de:	5d                   	pop    %ebp
715510df:	c2 10 00             	ret    $0x10
715510e2:	85 db                	test   %ebx,%ebx
715510e4:	74 f1                	je     715510d7 <_SecurityPageProc@16+0x17>
715510e6:	89 33                	mov    %esi,(%ebx)
715510e8:	50                   	push   %eax
715510e9:	50                   	push   %eax
715510ea:	68 e9 03 00 00       	push   $0x3e9
715510ef:	56                   	push   %esi
715510f0:	e8 0b 06 00 00       	call   71551700 <_GetDlgItem@8>
715510f5:	89 43 04             	mov    %eax,0x4(%ebx)
715510f8:	a1 00 30 55 71       	mov    0x71553000,%eax
715510fd:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
71551104:	6a 00                	push   $0x0
71551106:	6a 00                	push   $0x0
71551108:	6a 03                	push   $0x3
7155110a:	6a 10                	push   $0x10
7155110c:	68 e9 03 00 00       	push   $0x3e9
71551111:	50                   	push   %eax
71551112:	e8 b9 05 00 00       	call   715516d0 <_ImageList_LoadImageW@28>
71551117:	89 43 08             	mov    %eax,0x8(%ebx)
7155111a:	53                   	push   %ebx
7155111b:	6a 08                	push   $0x8
7155111d:	56                   	push   %esi
7155111e:	e8 ed 05 00 00       	call   71551710 <_SetWindowLongW@12>
71551123:	50                   	push   %eax
71551124:	8d 45 c8             	lea    0xffffffc8(%ebp),%eax
71551127:	50                   	push   %eax
71551128:	8b 73 04             	mov    0x4(%ebx),%esi
7155112b:	56                   	push   %esi
7155112c:	e8 ef 05 00 00       	call   71551720 <_GetClientRect@8>
71551131:	5a                   	pop    %edx
71551132:	59                   	pop    %ecx
71551133:	6a 20                	push   $0x20
71551135:	6a 20                	push   $0x20
71551137:	68 36 10 00 00       	push   $0x1036
7155113c:	8b 43 04             	mov    0x4(%ebx),%eax
7155113f:	50                   	push   %eax
71551140:	e8 eb 05 00 00       	call   71551730 <_SendMessageW@16>
71551145:	8b 43 08             	mov    0x8(%ebx),%eax
71551148:	50                   	push   %eax
71551149:	6a 01                	push   $0x1
7155114b:	68 03 10 00 00       	push   $0x1003
71551150:	8b 43 04             	mov    0x4(%ebx),%eax
71551153:	50                   	push   %eax
71551154:	e8 d7 05 00 00       	call   71551730 <_SendMessageW@16>
71551159:	8b 45 d0             	mov    0xffffffd0(%ebp),%eax
7155115c:	c7 45 d8 03 00 00 00 	movl   $0x3,0xffffffd8(%ebp)
71551163:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
71551166:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
71551169:	50                   	push   %eax
7155116a:	6a 00                	push   $0x0
7155116c:	68 61 10 00 00       	push   $0x1061
71551171:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
71551178:	8b 43 04             	mov    0x4(%ebx),%eax
7155117b:	50                   	push   %eax
7155117c:	e8 af 05 00 00       	call   71551730 <_SendMessageW@16>
71551181:	e9 51 ff ff ff       	jmp    715510d7 <_SecurityPageProc@16+0x17>
71551186:	8d 76 00             	lea    0x0(%esi),%esi
71551189:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

71551190 <_CreateSecurityPage@4>:


/*
 * CreateSecurityPage							EXPORTED
 *
 * @implemented
 */
HPROPSHEETPAGE
WINAPI
CreateSecurityPage(LPSECURITYINFO psi)
{
71551190:	55                   	push   %ebp
71551191:	89 e5                	mov    %esp,%ebp
71551193:	53                   	push   %ebx
71551194:	83 ec 64             	sub    $0x64,%esp
71551197:	8b 5d 08             	mov    0x8(%ebp),%ebx
  PROPSHEETPAGE psp;
  SI_OBJECT_INFO ObjectInfo;
  HRESULT hRet;

  if(psi == NULL)
7155119a:	85 db                	test   %ebx,%ebx
7155119c:	74 72                	je     71551210 <_CreateSecurityPage@4+0x80>
  {
    SetLastError(ERROR_INVALID_PARAMETER);

    DPRINT("No ISecurityInformation class passed!\n");
    return NULL;
  }

  /* get the object information from the server interface */
  hRet = psi->lpVtbl->GetObjectInformation(psi, &ObjectInfo);
7155119e:	50                   	push   %eax
7155119f:	50                   	push   %eax
715511a0:	8d 45 98             	lea    0xffffff98(%ebp),%eax
715511a3:	8b 13                	mov    (%ebx),%edx
715511a5:	50                   	push   %eax
715511a6:	53                   	push   %ebx
715511a7:	ff 52 0c             	call   *0xc(%edx)

  if(FAILED(hRet))
715511aa:	5a                   	pop    %edx
715511ab:	85 c0                	test   %eax,%eax
715511ad:	59                   	pop    %ecx
715511ae:	78 78                	js     71551228 <_CreateSecurityPage@4+0x98>
  {
    SetLastError(hRet);

    DPRINT("CreateSecurityPage() failed!\n");
    return NULL;
  }

  psp.dwSize = sizeof(PROPSHEETPAGE);
  psp.dwFlags = PSP_DEFAULT | PSP_USECALLBACK;
  psp.hInstance = hDllInstance;
715511b0:	a1 00 30 55 71       	mov    0x71553000,%eax
715511b5:	c7 45 c8 30 00 00 00 	movl   $0x30,0xffffffc8(%ebp)
715511bc:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
  psp.pszTemplate = MAKEINTRESOURCE(IDD_SECPAGE);
715511bf:	c7 45 d4 65 00 00 00 	movl   $0x65,0xffffffd4(%ebp)
  psp.pfnDlgProc = SecurityPageProc;
715511c6:	c7 45 e0 c0 10 55 71 	movl   $0x715510c0,0xffffffe0(%ebp)
  psp.lParam = (LPARAM)psi;
715511cd:	89 5d e4             	mov    %ebx,0xffffffe4(%ebp)
  psp.pfnCallback = SecurityPageCallback;
715511d0:	c7 45 e8 40 10 55 71 	movl   $0x71551040,0xffffffe8(%ebp)

  if((ObjectInfo.dwFlags & SI_PAGE_TITLE) != 0 &&
715511d7:	f6 45 99 08          	testb  $0x8,0xffffff99(%ebp)
715511db:	75 1a                	jne    715511f7 <_CreateSecurityPage@4+0x67>
715511dd:	c7 45 cc 80 00 00 00 	movl   $0x80,0xffffffcc(%ebp)
     ObjectInfo.pszPageTitle != NULL && ObjectInfo.pszPageTitle[0] != L'\0')
  {
    /* Set the page title if the flag is present and the string isn't empty */
    psp.pszTitle = ObjectInfo.pszPageTitle;
    psp.dwFlags |= PSP_USETITLE;
  }

  return CreatePropertySheetPage(&psp);
715511e4:	83 ec 0c             	sub    $0xc,%esp
715511e7:	8d 45 c8             	lea    0xffffffc8(%ebp),%eax
715511ea:	50                   	push   %eax
715511eb:	e8 f0 04 00 00       	call   715516e0 <_CreatePropertySheetPageW@4>
}
715511f0:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
715511f3:	c9                   	leave  
715511f4:	c2 04 00             	ret    $0x4
715511f7:	8b 45 a8             	mov    0xffffffa8(%ebp),%eax
715511fa:	85 c0                	test   %eax,%eax
715511fc:	74 df                	je     715511dd <_CreateSecurityPage@4+0x4d>
715511fe:	66 83 38 00          	cmpw   $0x0,(%eax)
71551202:	74 d9                	je     715511dd <_CreateSecurityPage@4+0x4d>
71551204:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
71551207:	c7 45 cc 88 00 00 00 	movl   $0x88,0xffffffcc(%ebp)
7155120e:	eb d4                	jmp    715511e4 <_CreateSecurityPage@4+0x54>
71551210:	83 ec 0c             	sub    $0xc,%esp
71551213:	6a 57                	push   $0x57
71551215:	e8 46 04 00 00       	call   71551660 <_SetLastError@4>
7155121a:	68 00 20 55 71       	push   $0x71552000
7155121f:	e8 8c 01 00 00       	call   715513b0 <_DbgPrint>
71551224:	31 c0                	xor    %eax,%eax
71551226:	eb c8                	jmp    715511f0 <_CreateSecurityPage@4+0x60>
71551228:	83 ec 0c             	sub    $0xc,%esp
7155122b:	50                   	push   %eax
7155122c:	e8 2f 04 00 00       	call   71551660 <_SetLastError@4>
71551231:	68 27 20 55 71       	push   $0x71552027
71551236:	eb e7                	jmp    7155121f <_CreateSecurityPage@4+0x8f>
71551238:	90                   	nop    
71551239:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

71551240 <_EditSecurity@8>:


/*
 * EditSecurity								EXPORTED
 *
 * @implemented
 */
BOOL
WINAPI
EditSecurity(HWND hwndOwner, LPSECURITYINFO psi)
{
71551240:	55                   	push   %ebp
71551241:	89 e5                	mov    %esp,%ebp
71551243:	53                   	push   %ebx
71551244:	81 ec 84 00 00 00    	sub    $0x84,%esp
7155124a:	8b 5d 0c             	mov    0xc(%ebp),%ebx
  HRESULT hRet;
  SI_OBJECT_INFO ObjectInfo;
  PROPSHEETHEADER psh;
  HPROPSHEETPAGE hPages[1];
  LPWSTR lpCaption;
  BOOL Ret;
  
  if(psi == NULL)
7155124d:	85 db                	test   %ebx,%ebx
7155124f:	0f 84 ed 00 00 00    	je     71551342 <_EditSecurity@8+0x102>
  {
    SetLastError(ERROR_INVALID_PARAMETER);
    
    DPRINT("No ISecurityInformation class passed!\n");
    return FALSE;
  }
  
  /* get the object information from the server interface */
  hRet = psi->lpVtbl->GetObjectInformation(psi, &ObjectInfo);
71551255:	50                   	push   %eax
71551256:	50                   	push   %eax
71551257:	8d 45 c8             	lea    0xffffffc8(%ebp),%eax
7155125a:	8b 13                	mov    (%ebx),%edx
7155125c:	50                   	push   %eax
7155125d:	53                   	push   %ebx
7155125e:	ff 52 0c             	call   *0xc(%edx)
  
  if(FAILED(hRet))
71551261:	5a                   	pop    %edx
71551262:	85 c0                	test   %eax,%eax
71551264:	59                   	pop    %ecx
71551265:	0f 88 f5 00 00 00    	js     71551360 <_EditSecurity@8+0x120>
  {
    SetLastError(hRet);
    
    DPRINT("GetObjectInformation() failed!\n");
    return FALSE;
  }

  /* create the page */
  hPages[0] = CreateSecurityPage(psi);
7155126b:	83 ec 0c             	sub    $0xc,%esp
7155126e:	53                   	push   %ebx
7155126f:	e8 1c ff ff ff       	call   71551190 <_CreateSecurityPage@4>
  if(hPages[0] == NULL)
71551274:	83 c4 0c             	add    $0xc,%esp
71551277:	85 c0                	test   %eax,%eax
71551279:	89 45 80             	mov    %eax,0xffffff80(%ebp)
7155127c:	74 42                	je     715512c0 <_EditSecurity@8+0x80>
  {
    DPRINT("CreateSecurityPage(), couldn't create property sheet!\n");
    return FALSE;
  }
  
  psh.dwSize = sizeof(PROPSHEETHEADER);
  psh.dwFlags = PSH_DEFAULT;
  psh.hwndParent = hwndOwner;
7155127e:	8b 45 08             	mov    0x8(%ebp),%eax
71551281:	c7 45 88 34 00 00 00 	movl   $0x34,0xffffff88(%ebp)
71551288:	89 45 90             	mov    %eax,0xffffff90(%ebp)
  psh.hInstance = hDllInstance;
7155128b:	a1 00 30 55 71       	mov    0x71553000,%eax
71551290:	c7 45 8c 00 00 00 00 	movl   $0x0,0xffffff8c(%ebp)
71551297:	89 45 94             	mov    %eax,0xffffff94(%ebp)
  if((ObjectInfo.dwFlags & SI_PAGE_TITLE) != 0 &&
7155129a:	f6 45 c9 08          	testb  $0x8,0xffffffc9(%ebp)
7155129e:	74 36                	je     715512d6 <_EditSecurity@8+0x96>
715512a0:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
715512a3:	85 c0                	test   %eax,%eax
715512a5:	74 2f                	je     715512d6 <_EditSecurity@8+0x96>
715512a7:	66 83 38 00          	cmpw   $0x0,(%eax)
715512ab:	74 29                	je     715512d6 <_EditSecurity@8+0x96>
     ObjectInfo.pszPageTitle != NULL && ObjectInfo.pszPageTitle[0] != L'\0')
  {
    /* Set the page title if the flag is present and the string isn't empty */
    psh.pszCaption = ObjectInfo.pszPageTitle;
715512ad:	89 45 9c             	mov    %eax,0xffffff9c(%ebp)
    lpCaption = NULL;
715512b0:	c7 45 84 00 00 00 00 	movl   $0x0,0xffffff84(%ebp)
715512b7:	eb 3e                	jmp    715512f7 <_EditSecurity@8+0xb7>
715512b9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
715512c0:	83 ec 0c             	sub    $0xc,%esp
715512c3:	68 48 20 55 71       	push   $0x71552048
715512c8:	e8 e3 00 00 00       	call   715513b0 <_DbgPrint>
715512cd:	31 c0                	xor    %eax,%eax
  }
  else
  {
    /* Set the page title to the object name, make sure the format string
       has "%1" NOT "%s" because it uses FormatMessage() to automatically
       allocate the right amount of memory. */
    RosLoadAndFormatStr(hDllInstance, IDS_PSP_TITLE, &lpCaption, ObjectInfo.pszObjectName);
    psh.pszCaption = lpCaption;
  }
  psh.nPages = sizeof(hPages) / sizeof(HPROPSHEETPAGE);
  psh.nStartPage = 0;
  psh.phpage = hPages;
  
  Ret = (PropertySheet(&psh) != -1);
  
  if(lpCaption != NULL)
  {
    LocalFree((HLOCAL)lpCaption);
  }
  
  return Ret;
}
715512cf:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
715512d2:	c9                   	leave  
715512d3:	c2 08 00             	ret    $0x8
715512d6:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
715512d9:	50                   	push   %eax
715512da:	8d 45 84             	lea    0xffffff84(%ebp),%eax
715512dd:	50                   	push   %eax
715512de:	68 e9 03 00 00       	push   $0x3e9
715512e3:	a1 00 30 55 71       	mov    0x71553000,%eax
715512e8:	50                   	push   %eax
715512e9:	e8 f2 02 00 00       	call   715515e0 <_RosLoadAndFormatStrW>
715512ee:	8b 45 84             	mov    0xffffff84(%ebp),%eax
715512f1:	83 c4 10             	add    $0x10,%esp
715512f4:	89 45 9c             	mov    %eax,0xffffff9c(%ebp)
715512f7:	83 ec 0c             	sub    $0xc,%esp
715512fa:	8d 45 80             	lea    0xffffff80(%ebp),%eax
715512fd:	89 45 a8             	mov    %eax,0xffffffa8(%ebp)
71551300:	c7 45 a0 01 00 00 00 	movl   $0x1,0xffffffa0(%ebp)
71551307:	c7 45 a4 00 00 00 00 	movl   $0x0,0xffffffa4(%ebp)
7155130e:	8d 45 88             	lea    0xffffff88(%ebp),%eax
71551311:	50                   	push   %eax
71551312:	e8 d9 03 00 00       	call   715516f0 <_PropertySheetW@4>
71551317:	83 c4 0c             	add    $0xc,%esp
7155131a:	40                   	inc    %eax
7155131b:	0f 95 c0             	setne  %al
7155131e:	31 db                	xor    %ebx,%ebx
71551320:	88 c3                	mov    %al,%bl
71551322:	8b 45 84             	mov    0xffffff84(%ebp),%eax
71551325:	85 c0                	test   %eax,%eax
71551327:	75 09                	jne    71551332 <_EditSecurity@8+0xf2>
71551329:	89 d8                	mov    %ebx,%eax
7155132b:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
7155132e:	c9                   	leave  
7155132f:	c2 08 00             	ret    $0x8
71551332:	83 ec 0c             	sub    $0xc,%esp
71551335:	50                   	push   %eax
71551336:	e8 05 03 00 00       	call   71551640 <_LocalFree@4>
7155133b:	89 d8                	mov    %ebx,%eax
7155133d:	83 c4 0c             	add    $0xc,%esp
71551340:	eb e9                	jmp    7155132b <_EditSecurity@8+0xeb>
71551342:	83 ec 0c             	sub    $0xc,%esp
71551345:	6a 57                	push   $0x57
71551347:	e8 14 03 00 00       	call   71551660 <_SetLastError@4>
7155134c:	68 00 20 55 71       	push   $0x71552000
71551351:	e8 5a 00 00 00       	call   715513b0 <_DbgPrint>
71551356:	e9 72 ff ff ff       	jmp    715512cd <_EditSecurity@8+0x8d>
7155135b:	90                   	nop    
7155135c:	8d 74 26 00          	lea    0x0(%esi),%esi
71551360:	83 ec 0c             	sub    $0xc,%esp
71551363:	50                   	push   %eax
71551364:	e8 f7 02 00 00       	call   71551660 <_SetLastError@4>
71551369:	68 80 20 55 71       	push   $0x71552080
7155136e:	e8 3d 00 00 00       	call   715513b0 <_DbgPrint>
71551373:	e9 55 ff ff ff       	jmp    715512cd <_EditSecurity@8+0x8d>
71551378:	90                   	nop    
71551379:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

71551380 <_DllMain@12>:

BOOL STDCALL
DllMain(HINSTANCE hinstDLL,
        DWORD dwReason,
        LPVOID lpvReserved)
{
71551380:	55                   	push   %ebp
71551381:	89 e5                	mov    %esp,%ebp
  switch (dwReason)
71551383:	83 7d 0c 01          	cmpl   $0x1,0xc(%ebp)
71551387:	74 09                	je     71551392 <_DllMain@12+0x12>
  {
    case DLL_PROCESS_ATTACH:
      hDllInstance = hinstDLL;
      break;
    case DLL_THREAD_ATTACH:
      break;
    case DLL_THREAD_DETACH:
      break;
    case DLL_PROCESS_DETACH:
      break;
  }
  return TRUE;
}
71551389:	b8 01 00 00 00       	mov    $0x1,%eax
7155138e:	5d                   	pop    %ebp
7155138f:	c2 0c 00             	ret    $0xc
71551392:	8b 45 08             	mov    0x8(%ebp),%eax
71551395:	5d                   	pop    %ebp
71551396:	a3 00 30 55 71       	mov    %eax,0x71553000
7155139b:	b8 01 00 00 00       	mov    $0x1,%eax
715513a0:	c2 0c 00             	ret    $0xc
715513a3:	90                   	nop    
715513a4:	90                   	nop    
715513a5:	90                   	nop    
715513a6:	90                   	nop    
715513a7:	90                   	nop    
715513a8:	90                   	nop    
715513a9:	90                   	nop    
715513aa:	90                   	nop    
715513ab:	90                   	nop    
715513ac:	90                   	nop    
715513ad:	90                   	nop    
715513ae:	90                   	nop    
715513af:	90                   	nop    

715513b0 <_DbgPrint>:
715513b0:	ff 25 14 51 55 71    	jmp    *0x71555114
715513b6:	90                   	nop    
715513b7:	90                   	nop    
	...

715513c0 <_RosLenOfStrResource>:
 * Returns -1 on failure.
 */
int
RosLenOfStrResource(HINSTANCE hInst, UINT uID)
{
715513c0:	55                   	push   %ebp
  HRSRC hrSrc;
  HGLOBAL hRes;
  LPWSTR lpName, lpStr;
  
  if(hInst == NULL)
  {
    return -1;
715513c1:	83 c8 ff             	or     $0xffffffff,%eax
715513c4:	89 e5                	mov    %esp,%ebp
715513c6:	56                   	push   %esi
715513c7:	53                   	push   %ebx
715513c8:	8b 75 08             	mov    0x8(%ebp),%esi
715513cb:	8b 5d 0c             	mov    0xc(%ebp),%ebx
715513ce:	85 f6                	test   %esi,%esi
715513d0:	74 59                	je     7155142b <_RosLenOfStrResource+0x6b>
  }
  
  /* There are always blocks of 16 strings */
  lpName = (LPWSTR)MAKEINTRESOURCE((uID >> 4) + 1);
715513d2:	89 d8                	mov    %ebx,%eax
715513d4:	c1 e8 04             	shr    $0x4,%eax

  /* Find the string table block */
  if((hrSrc = FindResourceW(hInst, lpName, (LPWSTR)RT_STRING)) &&
715513d7:	52                   	push   %edx
715513d8:	40                   	inc    %eax
715513d9:	6a 06                	push   $0x6
715513db:	25 ff ff 00 00       	and    $0xffff,%eax
715513e0:	50                   	push   %eax
715513e1:	56                   	push   %esi
715513e2:	e8 89 02 00 00       	call   71551670 <_FindResourceW@12>
715513e7:	59                   	pop    %ecx
715513e8:	85 c0                	test   %eax,%eax
715513ea:	74 46                	je     71551432 <_RosLenOfStrResource+0x72>
715513ec:	52                   	push   %edx
715513ed:	52                   	push   %edx
715513ee:	50                   	push   %eax
715513ef:	56                   	push   %esi
715513f0:	e8 8b 02 00 00       	call   71551680 <_LoadResource@8>
715513f5:	5a                   	pop    %edx
715513f6:	85 c0                	test   %eax,%eax
715513f8:	59                   	pop    %ecx
715513f9:	74 37                	je     71551432 <_RosLenOfStrResource+0x72>
715513fb:	83 ec 0c             	sub    $0xc,%esp
715513fe:	50                   	push   %eax
715513ff:	e8 8c 02 00 00       	call   71551690 <_LockResource@4>
71551404:	83 c4 0c             	add    $0xc,%esp
71551407:	89 c1                	mov    %eax,%ecx
71551409:	85 c0                	test   %eax,%eax
7155140b:	74 25                	je     71551432 <_RosLenOfStrResource+0x72>
     (hRes = LoadResource(hInst, hrSrc)) &&
     (lpStr = LockResource(hRes)))
  {
    UINT x;

    /* Find the string we're looking for */
    uID &= 0xF; /* position in the block, same as % 16 */
    for(x = 0; x < uID; x++)
7155140d:	83 e3 0f             	and    $0xf,%ebx
71551410:	74 11                	je     71551423 <_RosLenOfStrResource+0x63>
71551412:	89 da                	mov    %ebx,%edx
    {
      lpStr += (*lpStr) + 1;
71551414:	66 8b 01             	mov    (%ecx),%ax
71551417:	25 ff ff 00 00       	and    $0xffff,%eax
7155141c:	4a                   	dec    %edx
7155141d:	8d 4c 41 02          	lea    0x2(%ecx,%eax,2),%ecx
71551421:	75 f1                	jne    71551414 <_RosLenOfStrResource+0x54>
    }
    
    /* Found the string */
    return (int)(*lpStr);
71551423:	66 8b 01             	mov    (%ecx),%ax
71551426:	25 ff ff 00 00       	and    $0xffff,%eax
  }
  return -1;
}
7155142b:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
7155142e:	5b                   	pop    %ebx
7155142f:	5e                   	pop    %esi
71551430:	5d                   	pop    %ebp
71551431:	c3                   	ret    
71551432:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
71551435:	83 c8 ff             	or     $0xffffffff,%eax
71551438:	5b                   	pop    %ebx
71551439:	5e                   	pop    %esi
7155143a:	5d                   	pop    %ebp
7155143b:	c3                   	ret    
7155143c:	8d 74 26 00          	lea    0x0(%esi),%esi

71551440 <_RosAllocAndLoadStringA>:

/*
 * Utility to allocate and load a string from the string table
 *
 * OUT LPSTR *lpTarget -> Address to a variable that will get the address to the string allocated
 * IN  HINSTANCE hInst -> Instance of the module
 * IN  UINT uID        -> ID of the string to measure
 *
 * Returns the number of characters not including the null-terminator.
 * Returns 0 on failure. Use LocalFree() to free the memory allocated.
 */
int
RosAllocAndLoadStringA(LPSTR *lpTarget, HINSTANCE hInst, UINT uID)
{
71551440:	55                   	push   %ebp
71551441:	89 e5                	mov    %esp,%ebp
71551443:	57                   	push   %edi
71551444:	56                   	push   %esi
71551445:	53                   	push   %ebx
71551446:	83 ec 14             	sub    $0x14,%esp
71551449:	8b 7d 0c             	mov    0xc(%ebp),%edi
7155144c:	8b 75 10             	mov    0x10(%ebp),%esi
  int ln;
  
  ln = RosLenOfStrResource(hInst, uID);
7155144f:	56                   	push   %esi
71551450:	57                   	push   %edi
71551451:	e8 6a ff ff ff       	call   715513c0 <_RosLenOfStrResource>
  if(ln++ > 0)
71551456:	83 c4 10             	add    $0x10,%esp
71551459:	89 c3                	mov    %eax,%ebx
7155145b:	43                   	inc    %ebx
7155145c:	85 c0                	test   %eax,%eax
7155145e:	7e 15                	jle    71551475 <_RosAllocAndLoadStringA+0x35>
  {
    (*lpTarget) = (LPSTR)LocalAlloc(LMEM_FIXED, ln * sizeof(CHAR));
71551460:	50                   	push   %eax
71551461:	50                   	push   %eax
71551462:	53                   	push   %ebx
71551463:	6a 00                	push   $0x0
71551465:	e8 e6 01 00 00       	call   71551650 <_LocalAlloc@8>
7155146a:	8b 55 08             	mov    0x8(%ebp),%edx
    if((*lpTarget) != NULL)
7155146d:	85 c0                	test   %eax,%eax
7155146f:	89 02                	mov    %eax,(%edx)
71551471:	5a                   	pop    %edx
71551472:	59                   	pop    %ecx
71551473:	75 0b                	jne    71551480 <_RosAllocAndLoadStringA+0x40>
    {
      int Ret;
      if(!(Ret = LoadStringA(hInst, uID, *lpTarget, ln)))
      {
        LocalFree((HLOCAL)(*lpTarget));
      }
      return Ret;
    }
  }
  return 0;
}
71551475:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
71551478:	31 c0                	xor    %eax,%eax
7155147a:	5b                   	pop    %ebx
7155147b:	5e                   	pop    %esi
7155147c:	5f                   	pop    %edi
7155147d:	5d                   	pop    %ebp
7155147e:	c3                   	ret    
7155147f:	90                   	nop    
71551480:	53                   	push   %ebx
71551481:	50                   	push   %eax
71551482:	56                   	push   %esi
71551483:	57                   	push   %edi
71551484:	e8 b7 02 00 00       	call   71551740 <_LoadStringA@16>
71551489:	89 c3                	mov    %eax,%ebx
7155148b:	85 c0                	test   %eax,%eax
7155148d:	74 0a                	je     71551499 <_RosAllocAndLoadStringA+0x59>
7155148f:	89 d8                	mov    %ebx,%eax
71551491:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
71551494:	5b                   	pop    %ebx
71551495:	5e                   	pop    %esi
71551496:	5f                   	pop    %edi
71551497:	5d                   	pop    %ebp
71551498:	c3                   	ret    
71551499:	8b 45 08             	mov    0x8(%ebp),%eax
7155149c:	83 ec 0c             	sub    $0xc,%esp
7155149f:	8b 08                	mov    (%eax),%ecx
715514a1:	51                   	push   %ecx
715514a2:	e8 99 01 00 00       	call   71551640 <_LocalFree@4>
715514a7:	89 d8                	mov    %ebx,%eax
715514a9:	83 c4 0c             	add    $0xc,%esp
715514ac:	eb e3                	jmp    71551491 <_RosAllocAndLoadStringA+0x51>
715514ae:	89 f6                	mov    %esi,%esi

715514b0 <_RosAllocAndLoadStringW>:

/*
 * Utility to allocate and load a string from the string table
 *
 * OUT LPSTR *lpTarget -> Address to a variable that will get the address to the string allocated
 * IN  HINSTANCE hInst -> Instance of the module
 * IN  UINT uID        -> ID of the string to measure
 *
 * Returns the number of characters not including the null-terminator.
 * Returns 0 on failure. Use LocalFree() to free the memory allocated.
 */
int
RosAllocAndLoadStringW(LPWSTR *lpTarget, HINSTANCE hInst, UINT uID)
{
715514b0:	55                   	push   %ebp
715514b1:	89 e5                	mov    %esp,%ebp
715514b3:	57                   	push   %edi
715514b4:	56                   	push   %esi
715514b5:	53                   	push   %ebx
715514b6:	83 ec 14             	sub    $0x14,%esp
715514b9:	8b 7d 0c             	mov    0xc(%ebp),%edi
715514bc:	8b 75 10             	mov    0x10(%ebp),%esi
  int ln;

  ln = RosLenOfStrResource(hInst, uID);
715514bf:	56                   	push   %esi
715514c0:	57                   	push   %edi
715514c1:	e8 fa fe ff ff       	call   715513c0 <_RosLenOfStrResource>
  if(ln++ > 0)
715514c6:	83 c4 10             	add    $0x10,%esp
715514c9:	89 c3                	mov    %eax,%ebx
715514cb:	43                   	inc    %ebx
715514cc:	85 c0                	test   %eax,%eax
715514ce:	7e 18                	jle    715514e8 <_RosAllocAndLoadStringW+0x38>
  {
    (*lpTarget) = (LPWSTR)LocalAlloc(LMEM_FIXED, ln * sizeof(WCHAR));
715514d0:	50                   	push   %eax
715514d1:	50                   	push   %eax
715514d2:	8d 04 1b             	lea    (%ebx,%ebx,1),%eax
715514d5:	50                   	push   %eax
715514d6:	6a 00                	push   $0x0
715514d8:	e8 73 01 00 00       	call   71551650 <_LocalAlloc@8>
715514dd:	8b 55 08             	mov    0x8(%ebp),%edx
    if((*lpTarget) != NULL)
715514e0:	85 c0                	test   %eax,%eax
715514e2:	89 02                	mov    %eax,(%edx)
715514e4:	5a                   	pop    %edx
715514e5:	59                   	pop    %ecx
715514e6:	75 0a                	jne    715514f2 <_RosAllocAndLoadStringW+0x42>
    {
      int Ret;
      if(!(Ret = LoadStringW(hInst, uID, *lpTarget, ln)))
      {
        LocalFree((HLOCAL)(*lpTarget));
      }
      return Ret;
    }
  }
  return 0;
}
715514e8:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
715514eb:	31 c0                	xor    %eax,%eax
715514ed:	5b                   	pop    %ebx
715514ee:	5e                   	pop    %esi
715514ef:	5f                   	pop    %edi
715514f0:	5d                   	pop    %ebp
715514f1:	c3                   	ret    
715514f2:	53                   	push   %ebx
715514f3:	50                   	push   %eax
715514f4:	56                   	push   %esi
715514f5:	57                   	push   %edi
715514f6:	e8 55 02 00 00       	call   71551750 <_LoadStringW@16>
715514fb:	89 c3                	mov    %eax,%ebx
715514fd:	85 c0                	test   %eax,%eax
715514ff:	74 0a                	je     7155150b <_RosAllocAndLoadStringW+0x5b>
71551501:	89 d8                	mov    %ebx,%eax
71551503:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
71551506:	5b                   	pop    %ebx
71551507:	5e                   	pop    %esi
71551508:	5f                   	pop    %edi
71551509:	5d                   	pop    %ebp
7155150a:	c3                   	ret    
7155150b:	8b 45 08             	mov    0x8(%ebp),%eax
7155150e:	83 ec 0c             	sub    $0xc,%esp
71551511:	8b 00                	mov    (%eax),%eax
71551513:	50                   	push   %eax
71551514:	e8 27 01 00 00       	call   71551640 <_LocalFree@4>
71551519:	89 d8                	mov    %ebx,%eax
7155151b:	83 c4 0c             	add    $0xc,%esp
7155151e:	eb e3                	jmp    71551503 <_RosAllocAndLoadStringW+0x53>

71551520 <_RosFormatStrA>:

/*
 * Utility to allocate memory and format a string
 *
 * OUT LPSTR *lpTarget -> Address to a variable that will get the address to the string allocated
 * IN  LPSTR lpFormat  -> String which is to be formatted with the arguments given
 *
 * Returns the number of characters in lpTarget not including the null-terminator.
 * Returns 0 on failure. Use LocalFree() to free the memory allocated.
 */
DWORD
RosFormatStrA(LPSTR *lpTarget, LPSTR lpFormat, ...)
{
71551520:	55                   	push   %ebp
71551521:	89 e5                	mov    %esp,%ebp
71551523:	83 ec 0c             	sub    $0xc,%esp
  DWORD Ret;
  va_list lArgs;
  
  va_start(lArgs, lpFormat);
71551526:	8d 45 10             	lea    0x10(%ebp),%eax
71551529:	89 45 fc             	mov    %eax,0xfffffffc(%ebp)
  /* let's use FormatMessage to format it because it has the ability to allocate
     memory automatically */
  Ret = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
7155152c:	8d 45 fc             	lea    0xfffffffc(%ebp),%eax
7155152f:	50                   	push   %eax
71551530:	8b 45 08             	mov    0x8(%ebp),%eax
71551533:	6a 00                	push   $0x0
71551535:	50                   	push   %eax
71551536:	8b 45 0c             	mov    0xc(%ebp),%eax
71551539:	6a 00                	push   $0x0
7155153b:	6a 00                	push   $0x0
7155153d:	50                   	push   %eax
7155153e:	68 00 05 00 00       	push   $0x500
71551543:	e8 58 01 00 00       	call   715516a0 <_FormatMessageA@28>
                       lpFormat, 0, 0, (LPSTR)lpTarget, 0, &lArgs);
  va_end(lArgs);
  
  return Ret;
}
71551548:	c9                   	leave  
71551549:	c3                   	ret    
7155154a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

71551550 <_RosFormatStrW>:

/*
 * Utility to allocate memory and format a string
 *
 * OUT LPSTR *lpTarget -> Address to a variable that will get the address to the string allocated
 * IN  LPSTR lpFormat  -> String which is to be formatted with the arguments given
 *
 * Returns the number of characters in lpTarget not including the null-terminator.
 * Returns 0 on failure. Use LocalFree() to free the memory allocated.
 */
DWORD
RosFormatStrW(LPWSTR *lpTarget, LPWSTR lpFormat, ...)
{
71551550:	55                   	push   %ebp
71551551:	89 e5                	mov    %esp,%ebp
71551553:	83 ec 0c             	sub    $0xc,%esp
  DWORD Ret;
  va_list lArgs;

  va_start(lArgs, lpFormat);
71551556:	8d 45 10             	lea    0x10(%ebp),%eax
71551559:	89 45 fc             	mov    %eax,0xfffffffc(%ebp)
  /* let's use FormatMessage to format it because it has the ability to allocate
     memory automatically */
  Ret = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
7155155c:	8d 45 fc             	lea    0xfffffffc(%ebp),%eax
7155155f:	50                   	push   %eax
71551560:	8b 45 08             	mov    0x8(%ebp),%eax
71551563:	6a 00                	push   $0x0
71551565:	50                   	push   %eax
71551566:	8b 45 0c             	mov    0xc(%ebp),%eax
71551569:	6a 00                	push   $0x0
7155156b:	6a 00                	push   $0x0
7155156d:	50                   	push   %eax
7155156e:	68 00 05 00 00       	push   $0x500
71551573:	e8 38 01 00 00       	call   715516b0 <_FormatMessageW@28>
                       lpFormat, 0, 0, (LPWSTR)lpTarget, 0, &lArgs);
  va_end(lArgs);

  return Ret;
}
71551578:	c9                   	leave  
71551579:	c3                   	ret    
7155157a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

71551580 <_RosLoadAndFormatStrA>:

/*
 * Utility to allocate memory, load a string from the resources and format it
 *
 * IN  HINSTANCE hInst -> Instance of the module
 * IN  UINT uID        -> ID of the string to measure
 * OUT LPSTR *lpTarget -> Address to a variable that will get the address to the string allocated
 *
 * Returns the number of characters in lpTarget not including the null-terminator.
 * Returns 0 on failure. Use LocalFree() to free the memory allocated.
 */
DWORD
RosLoadAndFormatStrA(HINSTANCE hInst, UINT uID, LPSTR *lpTarget, ...)
{
71551580:	55                   	push   %ebp
71551581:	89 e5                	mov    %esp,%ebp
71551583:	53                   	push   %ebx
71551584:	83 ec 18             	sub    $0x18,%esp
  DWORD Ret = 0;
71551587:	31 db                	xor    %ebx,%ebx
  LPSTR lpFormat;
  va_list lArgs;
  
  if(RosAllocAndLoadStringA(&lpFormat, hInst, uID) > 0)
71551589:	8b 45 0c             	mov    0xc(%ebp),%eax
7155158c:	50                   	push   %eax
7155158d:	8b 45 08             	mov    0x8(%ebp),%eax
71551590:	50                   	push   %eax
71551591:	8d 45 f8             	lea    0xfffffff8(%ebp),%eax
71551594:	50                   	push   %eax
71551595:	e8 a6 fe ff ff       	call   71551440 <_RosAllocAndLoadStringA>
7155159a:	83 c4 10             	add    $0x10,%esp
7155159d:	85 c0                	test   %eax,%eax
7155159f:	7e 33                	jle    715515d4 <_RosLoadAndFormatStrA+0x54>
  {
    va_start(lArgs, lpTarget);
715515a1:	8d 45 14             	lea    0x14(%ebp),%eax
    /* let's use FormatMessage to format it because it has the ability to allocate
       memory automatically */
    Ret = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
715515a4:	8b 5d 10             	mov    0x10(%ebp),%ebx
715515a7:	89 45 f4             	mov    %eax,0xfffffff4(%ebp)
715515aa:	8b 4d f8             	mov    0xfffffff8(%ebp),%ecx
715515ad:	50                   	push   %eax
715515ae:	8d 45 f4             	lea    0xfffffff4(%ebp),%eax
715515b1:	50                   	push   %eax
715515b2:	6a 00                	push   $0x0
715515b4:	53                   	push   %ebx
715515b5:	6a 00                	push   $0x0
715515b7:	6a 00                	push   $0x0
715515b9:	51                   	push   %ecx
715515ba:	68 00 05 00 00       	push   $0x500
715515bf:	e8 dc 00 00 00       	call   715516a0 <_FormatMessageA@28>
715515c4:	89 c3                	mov    %eax,%ebx
                         lpFormat, 0, 0, (LPSTR)lpTarget, 0, &lArgs);
    va_end(lArgs);
    
    LocalFree((HLOCAL)lpFormat);
715515c6:	8b 45 f8             	mov    0xfffffff8(%ebp),%eax
715515c9:	52                   	push   %edx
715515ca:	52                   	push   %edx
715515cb:	50                   	push   %eax
715515cc:	e8 6f 00 00 00       	call   71551640 <_LocalFree@4>
715515d1:	83 c4 0c             	add    $0xc,%esp
  }
  
  return Ret;
}
715515d4:	89 d8                	mov    %ebx,%eax
715515d6:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
715515d9:	c9                   	leave  
715515da:	c3                   	ret    
715515db:	90                   	nop    
715515dc:	8d 74 26 00          	lea    0x0(%esi),%esi

715515e0 <_RosLoadAndFormatStrW>:

/*
 * Utility to allocate memory, load a string from the resources and format it
 *
 * IN  HINSTANCE hInst -> Instance of the module
 * IN  UINT uID        -> ID of the string to measure
 * OUT LPSTR *lpTarget -> Address to a variable that will get the address to the string allocated
 *
 * Returns the number of characters in lpTarget not including the null-terminator.
 * Returns 0 on failure. Use LocalFree() to free the memory allocated.
 */
DWORD
RosLoadAndFormatStrW(HINSTANCE hInst, UINT uID, LPWSTR *lpTarget, ...)
{
715515e0:	55                   	push   %ebp
715515e1:	89 e5                	mov    %esp,%ebp
715515e3:	53                   	push   %ebx
715515e4:	83 ec 18             	sub    $0x18,%esp
  DWORD Ret = 0;
715515e7:	31 db                	xor    %ebx,%ebx
  LPWSTR lpFormat;
  va_list lArgs;

  if(RosAllocAndLoadStringW(&lpFormat, hInst, uID) > 0)
715515e9:	8b 45 0c             	mov    0xc(%ebp),%eax
715515ec:	50                   	push   %eax
715515ed:	8b 45 08             	mov    0x8(%ebp),%eax
715515f0:	50                   	push   %eax
715515f1:	8d 45 f8             	lea    0xfffffff8(%ebp),%eax
715515f4:	50                   	push   %eax
715515f5:	e8 b6 fe ff ff       	call   715514b0 <_RosAllocAndLoadStringW>
715515fa:	83 c4 10             	add    $0x10,%esp
715515fd:	85 c0                	test   %eax,%eax
715515ff:	7e 33                	jle    71551634 <_RosLoadAndFormatStrW+0x54>
  {
    va_start(lArgs, lpTarget);
71551601:	8d 45 14             	lea    0x14(%ebp),%eax
    /* let's use FormatMessage to format it because it has the ability to allocate
       memory automatically */
    Ret = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
71551604:	8b 55 10             	mov    0x10(%ebp),%edx
71551607:	89 45 f4             	mov    %eax,0xfffffff4(%ebp)
7155160a:	8d 45 f4             	lea    0xfffffff4(%ebp),%eax
7155160d:	51                   	push   %ecx
7155160e:	50                   	push   %eax
7155160f:	8b 45 f8             	mov    0xfffffff8(%ebp),%eax
71551612:	6a 00                	push   $0x0
71551614:	52                   	push   %edx
71551615:	6a 00                	push   $0x0
71551617:	6a 00                	push   $0x0
71551619:	50                   	push   %eax
7155161a:	68 00 05 00 00       	push   $0x500
7155161f:	e8 8c 00 00 00       	call   715516b0 <_FormatMessageW@28>
71551624:	89 c3                	mov    %eax,%ebx
                         lpFormat, 0, 0, (LPWSTR)lpTarget, 0, &lArgs);
    va_end(lArgs);
    
    LocalFree((HLOCAL)lpFormat);
71551626:	50                   	push   %eax
71551627:	50                   	push   %eax
71551628:	8b 45 f8             	mov    0xfffffff8(%ebp),%eax
7155162b:	50                   	push   %eax
7155162c:	e8 0f 00 00 00       	call   71551640 <_LocalFree@4>
71551631:	83 c4 0c             	add    $0xc,%esp
  }
  
  return Ret;
}
71551634:	89 d8                	mov    %ebx,%eax
71551636:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
71551639:	c9                   	leave  
7155163a:	c3                   	ret    
7155163b:	90                   	nop    
7155163c:	90                   	nop    
7155163d:	90                   	nop    
7155163e:	90                   	nop    
7155163f:	90                   	nop    

71551640 <_LocalFree@4>:
71551640:	ff 25 00 51 55 71    	jmp    *0x71555100
71551646:	90                   	nop    
71551647:	90                   	nop    
	...

71551650 <_LocalAlloc@8>:
71551650:	ff 25 fc 50 55 71    	jmp    *0x715550fc
71551656:	90                   	nop    
71551657:	90                   	nop    
	...

71551660 <_SetLastError@4>:
71551660:	ff 25 08 51 55 71    	jmp    *0x71555108
71551666:	90                   	nop    
71551667:	90                   	nop    
	...

71551670 <_FindResourceW@12>:
71551670:	ff 25 ec 50 55 71    	jmp    *0x715550ec
71551676:	90                   	nop    
71551677:	90                   	nop    
	...

71551680 <_LoadResource@8>:
71551680:	ff 25 f8 50 55 71    	jmp    *0x715550f8
71551686:	90                   	nop    
71551687:	90                   	nop    
	...

71551690 <_LockResource@4>:
71551690:	ff 25 04 51 55 71    	jmp    *0x71555104
71551696:	90                   	nop    
71551697:	90                   	nop    
	...

715516a0 <_FormatMessageA@28>:
715516a0:	ff 25 f0 50 55 71    	jmp    *0x715550f0
715516a6:	90                   	nop    
715516a7:	90                   	nop    
	...

715516b0 <_FormatMessageW@28>:
715516b0:	ff 25 f4 50 55 71    	jmp    *0x715550f4
715516b6:	90                   	nop    
715516b7:	90                   	nop    
	...

715516c0 <_ImageList_Destroy@4>:
715516c0:	ff 25 d8 50 55 71    	jmp    *0x715550d8
715516c6:	90                   	nop    
715516c7:	90                   	nop    
	...

715516d0 <_ImageList_LoadImageW@28>:
715516d0:	ff 25 dc 50 55 71    	jmp    *0x715550dc
715516d6:	90                   	nop    
715516d7:	90                   	nop    
	...

715516e0 <_CreatePropertySheetPageW@4>:
715516e0:	ff 25 d4 50 55 71    	jmp    *0x715550d4
715516e6:	90                   	nop    
715516e7:	90                   	nop    
	...

715516f0 <_PropertySheetW@4>:
715516f0:	ff 25 e0 50 55 71    	jmp    *0x715550e0
715516f6:	90                   	nop    
715516f7:	90                   	nop    
	...

71551700 <_GetDlgItem@8>:
71551700:	ff 25 24 51 55 71    	jmp    *0x71555124
71551706:	90                   	nop    
71551707:	90                   	nop    
	...

71551710 <_SetWindowLongW@12>:
71551710:	ff 25 34 51 55 71    	jmp    *0x71555134
71551716:	90                   	nop    
71551717:	90                   	nop    
	...

71551720 <_GetClientRect@8>:
71551720:	ff 25 20 51 55 71    	jmp    *0x71555120
71551726:	90                   	nop    
71551727:	90                   	nop    
	...

71551730 <_SendMessageW@16>:
71551730:	ff 25 30 51 55 71    	jmp    *0x71555130
71551736:	90                   	nop    
71551737:	90                   	nop    
	...

71551740 <_LoadStringA@16>:
71551740:	ff 25 28 51 55 71    	jmp    *0x71555128
71551746:	90                   	nop    
71551747:	90                   	nop    
	...

71551750 <_LoadStringW@16>:
71551750:	ff 25 2c 51 55 71    	jmp    *0x7155512c
71551756:	90                   	nop    
71551757:	90                   	nop    
	...

71551760 <__CTOR_LIST__>:
71551760:	ff                   	(bad)  
71551761:	ff                   	(bad)  
71551762:	ff                   	(bad)  
71551763:	ff 00                	incl   (%eax)
71551765:	00 00                	add    %al,(%eax)
	...

71551768 <__DTOR_LIST__>:
71551768:	ff                   	(bad)  
71551769:	ff                   	(bad)  
7155176a:	ff                   	(bad)  
7155176b:	ff 00                	incl   (%eax)
7155176d:	00 00                	add    %al,(%eax)
	...
