HRESULT AddGraphToRot(IUnknown *pUnkGraph, DWORD *pdwRegister)
{
IMoniker * pMoniker;
IRunningObjectTable *pROT;
if (FAILED(GetRunningObjectTable(0, &pROT)))
{
return E_FAIL;
}
WCHAR wsz[128];
wsprintfW(wsz, L"FilterGraph %08x pid %08x", (DWORD_PTR)pUnkGraph,
GetCurrentProcessId());
HRESULT hr = CreateItemMoniker(L"!", wsz, &pMoniker);
if (SUCCEEDED(hr))
{
// Use the ROTFLAGS_REGISTRATIONKEEPSALIVE to ensure a strong reference
// to the object. Using this flag will cause the object to remain
// registered until it is explicitly revoked with the Revoke() method.
//
// Not using this flag means that if GraphEdit remotely connects
// to this graph and then GraphEdit exits, this object registration
// will be deleted, causing future attempts by GraphEdit to fail until
// this application is restarted or until the graph is registered again.
hr = pROT->Register(ROTFLAGS_REGISTRATIONKEEPSALIVE, pUnkGraph,
pMoniker, pdwRegister);
pMoniker->Release();
}
pROT->Release();
return hr;
}
/***********************************************************************
* RegisterActiveObject (OLEAUT32.33)
*
* Registers an object in the global item table.
*
* PARAMS
* punk [I] Object to register.
* rcid [I] CLSID of the object.
* dwFlags [I] Flags.
* pdwRegister [O] Address to store cookie of object registration in.
*
* RETURNS
* Success: S_OK.
* Failure: HRESULT code.
*/
HRESULT WINAPI RegisterActiveObject(
LPUNKNOWN punk,REFCLSID rcid,DWORD dwFlags,LPDWORD pdwRegister
) {
WCHAR guidbuf[80];
HRESULT ret;
LPRUNNINGOBJECTTABLE runobtable;
LPMONIKER moniker;
DWORD rot_flags = ROTFLAGS_REGISTRATIONKEEPSALIVE; /* default registration is strong */
StringFromGUID2(rcid,guidbuf,39);
ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
if (FAILED(ret))
return ret;
ret = GetRunningObjectTable(0,&runobtable);
if (FAILED(ret)) {
IMoniker_Release(moniker);
return ret;
}
if(dwFlags == ACTIVEOBJECT_WEAK)
rot_flags = 0;
ret = IRunningObjectTable_Register(runobtable,rot_flags,punk,moniker,pdwRegister);
IRunningObjectTable_Release(runobtable);
IMoniker_Release(moniker);
return ret;
}
static HRESULT WINAPI IHlinkBC_Register(IHlinkBrowseContext* iface,
DWORD dwReserved, IUnknown *piunk, IMoniker *pimk, DWORD *pdwRegister)
{
static const WCHAR szIdent[] = {'W','I','N','E','H','L','I','N','K',0};
HlinkBCImpl *This = impl_from_IHlinkBrowseContext(iface);
IMoniker *mon;
IMoniker *composite;
IRunningObjectTable *ROT;
HRESULT hr;
FIXME("(%p)->(%i %p %p %p)\n", This, dwReserved, piunk, pimk, pdwRegister);
hr = CreateItemMoniker(NULL, szIdent, &mon);
if (FAILED(hr))
return hr;
CreateGenericComposite(mon, pimk, &composite);
GetRunningObjectTable(0, &ROT);
IRunningObjectTable_Register(ROT, 0, piunk, composite, pdwRegister);
IRunningObjectTable_Release(ROT);
IMoniker_Release(composite);
IMoniker_Release(mon);
return S_OK;
}
HRESULT
AddGraphToRunningObjectTable(IUnknown *aUnkGraph, DWORD *aOutRotRegister)
{
HRESULT hr;
nsRefPtr<IMoniker> moniker;
nsRefPtr<IRunningObjectTable> runningObjectTable;
hr = GetRunningObjectTable(0, getter_AddRefs(runningObjectTable));
NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
const size_t STRING_LENGTH = 256;
WCHAR wsz[STRING_LENGTH];
StringCchPrintfW(wsz,
STRING_LENGTH,
L"FilterGraph %08x pid %08x",
(DWORD_PTR)aUnkGraph,
GetCurrentProcessId());
hr = CreateItemMoniker(L"!", wsz, getter_AddRefs(moniker));
NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
hr = runningObjectTable->Register(ROTFLAGS_REGISTRATIONKEEPSALIVE,
aUnkGraph,
moniker,
aOutRotRegister);
NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
return S_OK;
}
// address: 0x4012f8
void _start(int param1, int param2, int param3, int param4, RECT param5, int param6) {
int eax; // r24
union { __size32 * x7; unsigned int x8; } eax_1; // r24{257}
int ecx; // r25
int edx; // r26
unsigned int edx_1; // r26{338}
int esp; // r28
eax = GetCurrentProcessId();
if (eax != 1019) {
}
CharUpperA();
OpenEventW();
GetDC();
eax = GetCurrentThreadId(); /* Warning: also results in ecx */
if (eax == 621) {
ecx = ecx ^ param6;
}
if (ecx != 0) {
}
__set_app_type();
GetFileAttributesA();
CharUpperA();
GetProcessHeap();
CharUpperA();
OpenMutexA();
IsWindow();
eax = GetCurrentThreadId(); /* Warning: also results in ecx */
if ((eax & 0xae4) != ecx) {
}
eax = GetClientRect(0, ¶m5); /* Warning: also results in edx */
eax = eax | param4;
if (eax != edx) {
eax = (esp - 552);
edx = edx ^ param2;
edx = edx ^ param3;
edx = edx & param1;
}
eax_1 = eax;
edx_1 = edx;
edx = edx_1 ^ 0x21cd;
flags = SUBFLAGS32(eax_1, edx_1 ^ 0x21cd, eax_1 - (edx_1 ^ 0x21cd));
if (eax_1 != (edx_1 ^ 0x21cd)) {
edx = (edx_1 ^ 0x21cd) + (edx_1 ^ 0x21cd) + (eax_1 < (unsigned int)(edx_1 ^ 0x21cd));
eax_1 = eax_1 - 0x3421;
flags = SUBFLAGS32(eax_1, 0x3421, eax_1 - 0x3421);
}
if (eax_1 + edx + CF == 816) {
}
eax = CreateItemMoniker(); /* Warning: also results in edx */
if ((eax ^ 0x80070057) == 0) {
if ((eax ^ 0x80070057) + edx == 0) {
}
}
return;
}
SCODE _AfxParseDisplayName(LPMONIKER lpmk, LPBC lpbc, LPTSTR lpszRemainder,
ULONG* cchEaten, LPMONIKER* plpmkOut)
{
USES_CONVERSION;
ASSERT(lpmk != NULL);
ASSERT(AfxIsValidString(lpszRemainder));
ASSERT(cchEaten != NULL);
ASSERT(plpmkOut != NULL);
SCODE sc;
if (lpbc != NULL)
{
// ask moniker to parse the display name itself
sc = lpmk->ParseDisplayName(lpbc, NULL, T2OLE(lpszRemainder), cchEaten,
plpmkOut);
}
else
{
// skip leading delimiters
int cEaten = 0;
LPTSTR lpszSrc = lpszRemainder;
while (*lpszSrc != '\0' && (*lpszSrc == '\\' || *lpszSrc == '/' ||
*lpszSrc == ':' || *lpszSrc == '!' || *lpszSrc == '['))
{
if (_istlead(*lpszSrc))
++lpszSrc, ++cEaten;
++lpszSrc;
++cEaten;
}
// parse next token in lpszRemainder
TCHAR szItemName[_MAX_PATH];
LPTSTR lpszDest = szItemName;
while (*lpszSrc != '\0' && *lpszSrc != '\\' && *lpszSrc != '/' &&
*lpszSrc != ':' && *lpszSrc != '!' && *lpszSrc != '[' &&
cEaten < _MAX_PATH-1)
{
if (_istlead(*lpszSrc))
*lpszDest++ = *lpszSrc++, ++cEaten;
*lpszDest++ = *lpszSrc++;
++cEaten;
}
*cchEaten = cEaten;
sc = CreateItemMoniker(OLESTDDELIMOLE, T2COLE(szItemName), plpmkOut);
}
return sc;
}
HRESULT AddGraphToRot(IUnknown *pUnkGraph, DWORD *pdwRegister)
{
IMoniker * pMoniker;
IRunningObjectTable *pROT;
if (FAILED(GetRunningObjectTable(0, &pROT))) {
return E_FAIL;
}
WCHAR wsz[128];
wsprintfW(wsz, L"FilterGraph %08x pid %08x", (DWORD_PTR)pUnkGraph, GetCurrentProcessId());
HRESULT hr = CreateItemMoniker(L"!", wsz, &pMoniker);
if (SUCCEEDED(hr)) {
hr = pROT->Register(0, pUnkGraph, pMoniker, pdwRegister);
pMoniker->Release();
}
pROT->Release();
return hr;
}
//////////////////////// For GraphEdit Dubug purpose /////////////////////////////
void CDXGraph::AddToObjectTable(void)
{
IMoniker * pMoniker = 0;
IRunningObjectTable * objectTable = 0;
if (SUCCEEDED(GetRunningObjectTable(0, &objectTable)))
{
WCHAR wsz[256];
wsprintfW(wsz, L"FilterGraph %08p pid %08x", (DWORD_PTR)mGraph, GetCurrentProcessId());
HRESULT hr = CreateItemMoniker(L"!", wsz, &pMoniker);
if (SUCCEEDED(hr))
{
hr = objectTable->Register(0, mGraph, pMoniker, &mObjectTableEntry);
pMoniker->Release();
}
objectTable->Release();
}
}
HRESULT CTsReaderFilter::AddGraphToRot(IUnknown *pUnkGraph)
{
CComPtr <IMoniker> pMoniker;
CComPtr <IRunningObjectTable> pROT;
WCHAR wsz[128];
HRESULT hr;
if (m_dwGraphRegister!=0) return S_OK;
if (FAILED(GetRunningObjectTable(0, &pROT)))
return E_FAIL;
swprintf(wsz, L"FilterGraph %08x pid %08x\0", (DWORD_PTR) pUnkGraph, GetCurrentProcessId());
hr = CreateItemMoniker(L"!", wsz, &pMoniker);
if (SUCCEEDED(hr))
{
hr = pROT->Register(ROTFLAGS_REGISTRATIONKEEPSALIVE, pUnkGraph, pMoniker, &m_dwGraphRegister);
}
return hr;
}
static HRESULT AddToRot(IUnknown *pUnkGraph, DWORD *pdwRegister)
{
IMoniker *pMoniker = NULL;
IRunningObjectTable *pROT = NULL;
if (FAILED(GetRunningObjectTable(0, &pROT)))
return E_FAIL;
WCHAR wsz[256];
StringCchPrintfW(wsz, 256, L"FilterGraph %08x pid %08x (dsnative)", (DWORD_PTR) pUnkGraph, GetCurrentProcessId());
HRESULT hr = CreateItemMoniker(L"!", wsz, &pMoniker);
if (SUCCEEDED(hr))
{
hr = pROT->Register(ROTFLAGS_REGISTRATIONKEEPSALIVE, pUnkGraph, pMoniker, pdwRegister);
pMoniker->Release();
}
pROT->Release();
return hr;
}
//Добавляет текущий Filter Graph в ROT (Running Object Table)
//В случае ошибки функция вернет значение меньше нуля
int CDirectShow::AddFGToROT()
{
if (m_pGraphBuilder)
{
IMoniker *pMoniker = NULL;
IRunningObjectTable *pRunningObjectTable = NULL;
if (FAILED(GetRunningObjectTable(0, &pRunningObjectTable)))
{
return -1;
}
WCHAR lpwItem[256] = { 0 };
swprintf(lpwItem, L"FilterGraph %08p pid %08x", (LPDWORD)m_pGraphBuilder, GetCurrentProcessId());
if (FAILED(CreateItemMoniker(L"!", lpwItem, &pMoniker))) return -1;
pRunningObjectTable->Register(0, m_pGraphBuilder, pMoniker, &m_dwROTRegister);
pMoniker->Release();
pRunningObjectTable->Release();
return 0;
}
else return -1;
}
/***********************************************************************
* GetActiveObject (OLEAUT32.35)
*
* Gets an object from the global item table.
*
* PARAMS
* rcid [I] CLSID of the object.
* preserved [I] Reserved. Set to NULL.
* ppunk [O] Address to store object into.
*
* RETURNS
* Success: S_OK.
* Failure: HRESULT code.
*/
HRESULT WINAPI GetActiveObject(REFCLSID rcid,LPVOID preserved,LPUNKNOWN *ppunk)
{
WCHAR guidbuf[80];
HRESULT ret;
LPRUNNINGOBJECTTABLE runobtable;
LPMONIKER moniker;
StringFromGUID2(rcid,guidbuf,39);
ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
if (FAILED(ret))
return ret;
ret = GetRunningObjectTable(0,&runobtable);
if (FAILED(ret)) {
IMoniker_Release(moniker);
return ret;
}
ret = IRunningObjectTable_GetObject(runobtable,moniker,ppunk);
IRunningObjectTable_Release(runobtable);
IMoniker_Release(moniker);
return ret;
}
// Adds a DirectShow filter graph to the Running Object Table,
// allowing GraphEdit to "spy" on a remote filter graph.
HRESULT CBDAFilterGraph::AddGraphToRot(
IUnknown *pUnkGraph,
DWORD *pdwRegister
)
{
CComPtr <IMoniker> pMoniker;
CComPtr <IRunningObjectTable> pROT;
WCHAR wsz[128];
HRESULT hr;
if (FAILED(GetRunningObjectTable(0, &pROT)))
return E_FAIL;
wsprintfW(wsz, L"FilterGraph %08x pid %08x", (DWORD_PTR)pUnkGraph,
GetCurrentProcessId());
hr = CreateItemMoniker(L"!", wsz, &pMoniker);
if (SUCCEEDED(hr))
hr = pROT->Register(0, pUnkGraph, pMoniker, pdwRegister);
return hr;
}
/***********************************************************************
* RegisterActiveObject (OLEAUT32.33)
*
* Registers an object in the global item table.
*
* PARAMS
* punk [I] Object to register.
* rcid [I] CLSID of the object.
* dwFlags [I] Flags.
* pdwRegister [O] Address to store cookie of object registration in.
*
* RETURNS
* Success: S_OK.
* Failure: HRESULT code.
*/
HRESULT WINAPI RegisterActiveObject(
LPUNKNOWN punk,REFCLSID rcid,DWORD dwFlags,LPDWORD pdwRegister
) {
WCHAR guidbuf[80];
HRESULT ret;
LPRUNNINGOBJECTTABLE runobtable;
LPMONIKER moniker;
StringFromGUID2(rcid,guidbuf,39);
ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
if (FAILED(ret))
return ret;
ret = GetRunningObjectTable(0,&runobtable);
if (FAILED(ret)) {
IMoniker_Release(moniker);
return ret;
}
ret = IRunningObjectTable_Register(runobtable,dwFlags,punk,moniker,pdwRegister);
IRunningObjectTable_Release(runobtable);
IMoniker_Release(moniker);
return ret;
}
// Function name : CVMR9Graph::AddToRot
// Description : let the graph instance be accessible from graphedit
// Return type : HRESULT
// Argument : IUnknown *pUnkGraph
// Argument : DWORD *pdwRegister
HRESULT CVMR9Graph::AddToRot(IUnknown *pUnkGraph)
{
if (pUnkGraph == NULL) {
return E_INVALIDARG;
}
IMoniker * pMoniker;
IRunningObjectTable *pROT;
if (FAILED(GetRunningObjectTable(0, &pROT))) {
return E_FAIL;
}
WCHAR wsz[256];
wsprintfW(wsz, L"FilterGraph %08x pid %08x", (DWORD_PTR)pUnkGraph, GetCurrentProcessId());
HRESULT hr = CreateItemMoniker(L"!", wsz, &pMoniker);
if (SUCCEEDED(hr)) {
hr = pROT->Register(0, pUnkGraph, pMoniker, &m_dwRotId);
pMoniker->Release();
}
pROT->Release();
return hr;
}
//-----------------------------------------------------------------------------
// AddGraphToRot
// Adds a DirectShow filter graph to the Running Object Table,
// allowing GraphEdit to "spy" on a remote filter graph.
HRESULT CDSUtils::AddGraphToRot(IUnknown* pUnkGraph, DWORD* pdwRegister)
{
HRESULT hr = S_OK;
if (pUnkGraph && pdwRegister)
{
CComPtr<IRunningObjectTable> pROT = NULL;
hr = GetRunningObjectTable(0, &pROT);
if (SUCCEEDED(hr))
{
WCHAR wsz[128];
StringCchPrintfW(wsz, 128, L"FilterGraph %08x pid %08x\0", (DWORD_PTR)pUnkGraph, GetCurrentProcessId());
CComPtr<IMoniker> pMoniker = NULL;
hr = CreateItemMoniker(L"!", wsz, &pMoniker);
if(SUCCEEDED(hr))
{
// Use the ROTFLAGS_REGISTRATIONKEEPSALIVE to ensure a strong reference
// to the object. Using this flag will cause the object to remain
// registered until it is explicitly revoked with the Revoke() method.
//
// Not using this flag means that if GraphEdit remotely connects
// to this graph and then GraphEdit exits, this object registration
// will be deleted, causing future attempts by GraphEdit to fail until
// this application is restarted or until the graph is registered again.
hr = pROT->Register(ROTFLAGS_REGISTRATIONKEEPSALIVE, pUnkGraph, pMoniker, pdwRegister);
}
}
}
else
{
hr = E_INVALIDARG;
}
return hr;
}
// register in the running object table for graph debugging
STDMETHODIMP
BridgeSource::JoinFilterGraph(IFilterGraph * pGraph, LPCWSTR pName)
{
HRESULT hr = CBaseFilter::JoinFilterGraph(pGraph, pName);
// for debugging, we register in the ROT so that you can use
// Graphedt's Connect command to view the graphs
// disabled by default owing to refcount leak issue
if (false) //SUCCEEDED(hr))
{
if (pGraph == NULL)
{
if (m_dwROT) {
IRunningObjectTablePtr pROT;
if (SUCCEEDED(GetRunningObjectTable(0, &pROT))) {
pROT->Revoke(m_dwROT);
}
}
} else {
IMonikerPtr pMoniker;
IRunningObjectTablePtr pROT;
if (SUCCEEDED(GetRunningObjectTable(0, &pROT))) {
ostringstream strm;
DWORD graphaddress = (DWORD)((DWORD_PTR)(IUnknown*)pGraph) & 0xFFFFFFFF;
strm << "FilterGraph " << hex << graphaddress << " pid " << hex << GetCurrentProcessId();
_bstr_t strName = strm.str().c_str();
HRESULT hr = CreateItemMoniker(L"!", strName, &pMoniker);
if (SUCCEEDED(hr)) {
hr = pROT->Register(0, pGraph, pMoniker, &m_dwROT);
}
}
}
}
return hr;
}
int BookServerTest::readItemMoniker()
{
ComPtr<IStorage> pStorage;
ComPtr<IStream> pStream;
auto hr = StgOpenStorageEx(kMonikerFileName,
STGM_READ | STGM_SHARE_EXCLUSIVE | STGM_DIRECT, STGFMT_STORAGE, 0, NULL, 0, IID_IStorage, (void**)&pStorage);
if (FAILED(hr))
return hr;
hr = pStorage->OpenStream(kStreamName, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &pStream);
if (FAILED(hr))
return hr;
IBindCtx* pbc;
CreateBindCtx(0, &pbc);
ComPtr<IMoniker> bkMoniker;
OleLoadFromStream(pStream, IID_IMoniker, (void**)&bkMoniker);
{
ComPtr<IBook> book;
ComPtr<IBook> book2;
auto hr = bkMoniker->BindToObject(pbc, NULL, IID_IBook, (void**)&book);
assert(book);
//hr = bkMoniker->BindToObject(pbc, NULL, IID_IBook, (void**)&book2);
//assert(book2);
}
{
ComPtr<IMoniker> chMoniker;
CreateItemMoniker(L"!", L"chapter0", &chMoniker);
ComPtr<IChapter> chObj;
hr = chMoniker->BindToObject(pbc, bkMoniker, IID_IChapter, (void**)&chObj);
if (FAILED(hr))
return hr;
ComBSTR chName;
chObj->get_name(&chName);
assert(chName == L"概述");
}
{
ComPtr<ISection> secObj;
ComPtr<IMoniker> chMoniker;
ComPtr<IMoniker> secMoniker;
CreateItemMoniker(L"!", L"chapter0", &chMoniker);
CreateItemMoniker(L"!", L"section0", &secMoniker);
ComPtr<IMoniker> composeMoniker;
chMoniker->ComposeWith(secMoniker, FALSE, &composeMoniker);
hr = composeMoniker->BindToObject(pbc, bkMoniker, IID_ISection, (void**)&secObj);
if (FAILED(hr))
return hr;
ComBSTR name;
secObj->get_name(&name);
}
//ComPtr<IMoniker> secMoniker;
//CreateItemMoniker(L"!", L"section0", &secMoniker);
//ComPtr<ISection> secObj;
//hr = secMoniker->BindToObject(pbc, bkMoniker, IID_ISection, (void**)&secObj);
//if (FAILED(hr))
// return hr;
//ComBSTR secName;
//secObj->get_name(&secName);
//assert(secName == L"how to read this book");
//chObj = NULL;
//ComPtr<IMoniker> composeMoniker;
//hr = bkMoniker->ComposeWith(chMoniker, FALSE, &composeMoniker);
//if (FAILED(hr))
// return hr;
//composeMoniker->BindToObject(pbc, NULL, IID_IChapter, (void**)&chObj);
//chObj->get_name(&chName);
//assert(chName == L"概述");
//CreateGenericComposite(bkMoniker, chMoniker, &composeMoniker);
return 0;
}
void fn004012F8(word32 edx, word32 ebp, word32 dwArg00, word32 dwArg01, word32 dwArg05, word32 dwArg0B)
{
// def fp
// def dwArg00
// def dwArg01
// def dwLoc0120
// def dwLocB8
// def dwLoc0180
// def dwLoc03
// def dwLoc0154
// def dwLoc01B4
// def dwArg0B
// def dwLoc010E
// def dwLoc0118
// def dwLoc4C
// def dwLoc8C
// def dwLoc0234
// def dwLocBD
// def dwLocC3
// def dwLoc0225
// def dwLoc021C
// def dwLoc0227
// def dwLoc0140
// def dwArg05
eax_7 = GetCurrentProcessId();
if (eax_7 != 0x000003FB)
;
dwLoc0268_28 = fp - 0x00000004;
v15_29 = fp - 0x00000098;
dwLoc0268_30 = fp - 0x00000098;
CharUpperA(fp - 0x00000098);
ecx_36 = &fp->dwFFFFFD98;
dwLoc0268_38 = &fp->dwFFFFFD98;
dwLoc026C_41 = 0x00000000;
dwLoc0270_43.u0 = 0x00000000;
OpenEventW(0x00000000, 0x00000000, &fp->dwFFFFFD98);
dwLoc0268_52 = 0x00000000;
GetDC(0x00000000);
eax_55 = GetCurrentThreadId();
if (eax_55 == 0x0000026D)
ecx_595 = &fp->dwFFFFFD98 ^ dwArg05;
// ecx_64 = PHI(ecx_36, ecx_595)
esp_68 = fp - 0x00000268;
fp->dwFFFFFD98 = 0x00000002;
if (ecx_64 != 0x00000000)
;
__set_app_type();
dwLoc026C_85 = fp - 0x00000004;
v20_86 = fp - 0x000000B4;
dwLoc026C_87 = fp - 0x000000B4;
GetFileAttributesA(fp - 0x000000B4);
dwLoc026C_92 = &fp->dwFFFFFD98;
CharUpperA(&fp->dwFFFFFD98);
GetProcessHeap();
dwLoc026C_98 = &fp->dwFFFFFD98;
eax_99 = CharUpperA(&fp->dwFFFFFD98);
dwLoc026C_107 = &fp->dwFFFFFD98;
esp_108 = &fp->tFFFFFD90;
fp->tFFFFFD90.u0 = 0x00000000;
eax_110 = eax_99 & 0x00000008;
dwLoc0274_112 = eax_99 & 0x00000008;
eax_113 = OpenMutexA(eax_99 & 0x00000008, 0x00000000, &fp->dwFFFFFD98);
ecx_115 = &fp->dwFFFFFD98 & 0x0000011C;
eax_118 = eax_113 - dwArg00;
ecx_120 = ecx_115 - dwArg01;
dwLoc026C_122 = eax_118;
IsWindow(eax_118);
v22_126 = dwLoc0120 - (fp - 0x00000004);
dwLoc0120_127 = v22_126;
edx_128 = fp - 0x00000004 ^ 0x00000611;
eax_129 = GetCurrentThreadId();
eax_130 = eax_129 & 0x00000AE4;
if ((eax_129 & 0x00000AE4) != ecx_120)
{
edx_564 = edx_128 | ecx_120;
ecx_566 = ecx_120 | dwLoc0140;
v25_570 = dwLocB8 + ecx_566;
dwLocB8_571 = v25_570;
ecx_572 = fp - 0x00000004;
}
// dwLocB8_142 = PHI(dwLocB8, dwLocB8_571)
// ecx_143 = PHI(ecx_120, ecx_572)
// edx_144 = PHI(edx_128, edx_564)
dwLoc026C_148 = fp - 0x00000004;
v26_149 = fp - 0x00000060;
dwLoc026C_150 = fp - 0x00000060;
esp_151 = &fp->tFFFFFD90;
fp->tFFFFFD90.u0 = 0x00000000;
eax_153 = GetClientRect(0x00000000, fp - 0x00000060);
eax_156 = eax_153 | dwLoc0180;
if (eax_156 != edx_144)
{
eax_552 = &fp->dwFFFFFD98;
edx_556 = edx_144 ^ dwLoc0225;
edx_558 = edx_556 ^ dwLoc021C;
edx_560 = edx_558 & dwLoc0227;
}
// edx_165 = PHI(edx_144, edx_560)
// eax_166 = PHI(eax_156, eax_552)
edx_169 = edx_165 ^ 0x000021CD;
SCZO_170 = cond(eax_166 - edx_169);
C_173 = SCZO_170;
if (eax_166 != edx_169)
{
edx_534 = edx_169 * 0x00000002 + (eax_166 <u edx_169);
ecx_535 = ecx_143 + v22_126;
eax_542 = eax_166 - 0x00003421;
SCZO_545 = cond(eax_542);
C_548 = SCZO_545;
}
// ecx_179 = PHI(ecx_143, ecx_535)
// edx_180 = PHI(edx_169, edx_534)
// eax_181 = PHI(eax_166, eax_542)
// C_182 = PHI(C_173, C_548)
esp_183 = &fp->tFFFFFD90;
fp->tFFFFFD90.u0 = 0x00000000;
eax_185 = eax_181 + edx_180 + C_182;
if (eax_185 == 0x00000330)
{
edx_530 = edx_180 ^ 0x00001DF0;
ecx_531 = ecx_179 - 0x0000292F;
}
// ecx_193 = PHI(ecx_179, ecx_531)
// edx_194 = PHI(edx_180, edx_530)
dwLoc0274_197 = 0x00000000;
eax_198 = CreateItemMoniker(0x00000000, 0x00000000, null);
eax_200 = eax_198 ^ 0x80070057;
if ((eax_198 ^ 0x80070057) == 0x00000000)
{
eax_271 = (eax_198 ^ 0x80070057) + edx_194;
if (eax_271 == 0x00000000)
{
edx_521 = &fp->dwFFFFFD98;
eax_522 = eax_271 - dwLocB8_142;
ecx_525 = ecx_193 & dwLocBD;
ecx_527 = ecx_525 - dwLocC3;
}
// ecx_278 = PHI(ecx_193, ecx_527)
// edx_279 = PHI(edx_194, edx_521)
// eax_280 = PHI(eax_271, eax_522)
esp_281 = &fp->dwFFFFFD94;
fp->dwFFFFFD94 = eax_280;
esp_283 = &fp->tFFFFFD90;
fp->tFFFFFD90 = ecx_278;
esp_285 = &fp->dwFFFFFD8C;
fp->dwFFFFFD8C = edx_279;
ecx_299 = ecx_278 & 0x00002F37;
ecx_305 = ecx_299 + dwLoc03;
if (fp - 0x00000004 != ecx_305)
ecx_508 = &fp->dwFFFFFD98;
// ecx_316 = PHI(ecx_305, ecx_508)
if (ecx_316 != 0x00000000)
;
dwLoc0294_329 = 0x00002000;
dwLoc0298_334 = 0x00000000;
eax_337 = VirtualAlloc(0x00000000, 0x00002000, 0x00001000, 0x00000040);
dwLoc0218_340 = eax_337;
if (dwLoc0154 == ecx_316)
{
ecx_487 = ecx_316 + 0x00001D56;
ecx_491 = ecx_487 ^ 0x00002863;
}
// ecx_350 = PHI(ecx_316, ecx_491)
ecx_354 = ecx_350 - dwLoc01B4;
ecx_358 = ecx_354 | dwArg0B;
eax_361 = fp - 0x00000004 ^ dwLoc010E;
eax_363 = eax_361 + dwLoc0118;
edi_365 = &globals->dw412E33;
ecx_366 = ecx_358 + eax_363;
esi_367 = eax_337;
edx_370 = fp + 0xFFFFDB3F;
dwLoc68_371 = 0xA37A6ED7;
ecx_372 = ecx_366 - 0x000028C3;
if (ecx_366 != 0x000028C3)
{
ecx_475 = ecx_366 - 0x000028C3 | 0x000028C3;
goto l00401606;
}
l00401606:
do
{
// dwLoc68_378 = PHI(dwLoc68_371, dwLoc68_371, dwLoc68_393)
// edi_382 = PHI(edi_365, edi_365, edi_413)
// esi_383 = PHI(esi_367, esi_367, esi_415)
// ecx_384 = PHI(ecx_372, ecx_475, ecx_402)
// edx_385 = PHI(edx_370, edx_370, edx_414)
// eax_386 = PHI(eax_363, eax_363, eax_424)
ebx_388 = *edi_382;
ecx_390 = ecx_384 ^ dwLoc4C;
ebx_391 = ebx_388 + dwLoc68_378;
v44_392 = dwLoc68_378 + 0x623ED7F6;
dwLoc68_393 = v44_392;
ecx_394 = ecx_390 & edx_385;
C_395 = false;
edx_396 = edx_385 - eax_386;
Mem397[esi_383 + 0x00000000:word32] = ebx_391;
eax_398 = eax_386 | 0x00002279;
edi_400 = edi_382 + 20138706;
ecx_402 = ecx_394 - dwLoc8C;
esi_404 = esi_383 + 0xA596E2A8;
if (eax_398 == 0x000003EF)
{
eax_466 = eax_398 | 0x000038A7;
edx_468 = &fp->dwFFFFFD98 - ecx_402;
eax_469 = (eax_398 | 0x000038A7) & 0x00003565;
}
// edx_410 = PHI(edx_396, edx_468)
// eax_412 = PHI(eax_398, eax_469)
edi_413 = edi_400 + 0x04CD2B4C;
edx_414 = edx_410 + 0x00003BBE;
esi_415 = esi_404 + 0x5A691D5C;
if ((dwLoc0234 & ecx_402) != 0x00000000)
eax_461 = eax_412 ^ 0x000034ED;
// eax_424 = PHI(eax_412, eax_461)
} while (edi_413 != &globals->dw413EBF);
dwLoc0218_340();
if (eax_424 == edx_414)
;
}
