Galax DeviceDll.dll decompiled c code

DeviceDLL.dll.c

void** g1000d050 = reinterpret_cast<void**>(78);

int32_t HidD_GetPreparsedData = 0xc838;

int32_t HidP_GetCaps = 0xc7d8;

int32_t HidD_FreePreparsedData = 0xc7fa;

void** fun_10001cc4(void** ecx, void** a2, ...);

void** fun_10001000(void** a1) {
    void* ebp2;
    void** eax3;
    uint32_t v4;
    void* v5;
    signed char al6;
    void* v7;
    int32_t v8;
    int32_t eax9;
    void** v10;
    signed char al11;
    void** ecx12;
    void** eax13;
    void** ecx14;
    void** eax15;

    ebp2 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    eax3 = g1000d050;
    v4 = reinterpret_cast<unsigned char>(eax3) ^ reinterpret_cast<uint32_t>(ebp2);
    v5 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ebp2) - 80);
    al6 = reinterpret_cast<signed char>(HidD_GetPreparsedData(a1, v5));
    if (!al6 || ((v7 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ebp2) - 76), eax9 = reinterpret_cast<int32_t>(HidP_GetCaps(v8, v7, a1, v5)), eax9 != 0x110000) || (al11 = reinterpret_cast<signed char>(HidD_FreePreparsedData(v10, v8, v7, a1, v5)), al11 == 0))) {
        ecx12 = reinterpret_cast<void**>(v4 ^ reinterpret_cast<uint32_t>(ebp2));
        eax13 = fun_10001cc4(ecx12, a1, ecx12, a1);
        return eax13;
    } else {
        ecx14 = reinterpret_cast<void**>(v4 ^ reinterpret_cast<uint32_t>(ebp2));
        eax15 = fun_10001cc4(ecx14, v10, ecx14, v10);
        return eax15;
    }
}

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

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

    eax27 = a2;
    if (eax27 && (eax27 = eax27 - 8, reinterpret_cast<int1_t>(*reinterpret_cast<void***>(eax27) == 0xdddd))) {
        eax27 = fun_10002416(ecx, eax27, ebp28, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16);
    }
    return eax27;
}

int32_t g1000df50 = 0;

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

int32_t g1000df48 = 0;

int32_t g1000df44 = 0;

int32_t g1000df40 = 0;

int32_t g1000df3c = 0;

int16_t g1000df68 = 0;

int16_t g1000df5c = 0;

int16_t g1000df38 = 0;

int16_t g1000df34 = 0;

int16_t g1000df30 = 0;

int16_t g1000df2c = 0;

uint32_t g1000df60 = 0;

int32_t g1000df54 = 0;

int32_t g1000df58 = 0;

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

int32_t g1000dea0 = 0;

int32_t g1000de54 = 0;

int32_t g1000de48 = 0;

int32_t g1000de4c = 0;

int32_t g1000d054 = 0x44bf19b1;

int32_t IsDebuggerPresent = 0xc9d0;

int32_t g1000de98 = 0;

void fun_10004ccf(void** ecx);

int32_t SetUnhandledExceptionFilter = 0xc9b2;

int32_t UnhandledExceptionFilter = 0xc996;

int32_t GetCurrentProcess = 0xc982;

int32_t TerminateProcess = 0xc96e;

void** fun_10001cc4(void** ecx, void** a2, ...) {
    uint32_t eflags3;
    int1_t zf4;
    void** eax5;
    int32_t* esp6;
    void* esp7;
    int32_t eax8;
    int32_t edx9;
    int32_t ebx10;
    int32_t esi11;
    int32_t edi12;
    int16_t ss13;
    int16_t cs14;
    int16_t ds15;
    int16_t es16;
    int16_t fs17;
    int16_t gs18;
    int32_t ebp19;
    int32_t eax20;
    void** eax21;
    int32_t eax22;
    int32_t eax23;
    int1_t zf24;
    int32_t eax25;
    void** eax26;

    *reinterpret_cast<int1_t*>(reinterpret_cast<int32_t>(&eflags3) + 1) = 0;
    zf4 = ecx == g1000d050;
    if (zf4) {
        return eax5;
    }
    esp6 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    *reinterpret_cast<int1_t*>(&eflags3) = reinterpret_cast<uint32_t>(esp6) < 0x328;
    esp7 = reinterpret_cast<void*>(esp6 - 0xca);
    *reinterpret_cast<int1_t*>(&eflags3) = __intrinsic();
    *reinterpret_cast<int1_t*>(&eflags3) = esp7 == 0;
    *reinterpret_cast<int1_t*>(&eflags3) = reinterpret_cast<int32_t>(esp7) < reinterpret_cast<int32_t>(0);
    *reinterpret_cast<int1_t*>(reinterpret_cast<int32_t>(&eflags3) + 1) = __intrinsic();
    *reinterpret_cast<int1_t*>(&eflags3) = __intrinsic();
    g1000df50 = eax8;
    g1000df4c = ecx;
    g1000df48 = edx9;
    g1000df44 = ebx10;
    g1000df40 = esi11;
    g1000df3c = edi12;
    g1000df68 = ss13;
    g1000df5c = cs14;
    g1000df38 = ds15;
    g1000df34 = es16;
    g1000df30 = fs17;
    g1000df2c = gs18;
    g1000df60 = eflags3 & 0xfcffff;
    g1000df54 = ebp19;
    g1000df58 = reinterpret_cast<int32_t>(__return_address());
    g1000df64 = reinterpret_cast<void*>(esp6 + 2);
    g1000dea0 = 0x10001;
    eax20 = g1000df58;
    g1000de54 = eax20;
    g1000de48 = 0xc0000409;
    g1000de4c = 1;
    eax21 = g1000d050;
    eax22 = g1000d054;
    eax23 = reinterpret_cast<int32_t>(IsDebuggerPresent(eax21, eax22));
    g1000de98 = eax23;
    fun_10004ccf(ecx);
    SetUnhandledExceptionFilter(1, 0, eax21, eax22);
    UnhandledExceptionFilter(1, 0x1000a1b4, 0, eax21, eax22);
    zf24 = g1000de98 == 0;
    if (zf24) 
        goto addr_1000253a_5;
    addr_10002542_6:
    eax25 = reinterpret_cast<int32_t>(GetCurrentProcess(1, 0xc0000409, 0x1000a1b4, 0, eax21, eax22));
    eax26 = reinterpret_cast<void**>(TerminateProcess(1, eax25, 0xc0000409, 0x1000a1b4, 0, eax21, eax22));
    return eax26;
    addr_1000253a_5:
    fun_10004ccf(1);
    goto addr_10002542_6;
}

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

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

uint32_t g1000de40 = 0;

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

int32_t g1000de34 = 0;

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

void fun_100092fb();

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

void fun_10004c83(void** ecx, void* a2, unsigned char* a3);

void** g1000e2e8;

int32_t HeapFree = 0xc962;

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

int32_t GetLastError = 0xc8f6;

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

void** fun_10001cae(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12) {
    void** v13;
    void** v14;
    void** ebp15;
    void** ebp16;
    void** ecx17;
    void** v18;
    void** v19;
    void** v20;
    void** v21;
    void** eax22;
    void** v23;
    void** v24;
    void** v25;
    void** v26;
    int32_t eax27;
    int1_t zf28;
    void** v29;
    void** ecx30;
    void** v31;
    void** v32;
    void** v33;
    int32_t v34;
    void** v35;
    void** v36;
    void** eax37;
    void** v38;
    void** v39;
    void** eax40;
    void** eax41;
    void** eax42;

    v13 = reinterpret_cast<void**>(__return_address());
    v14 = ebp15;
    ebp16 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 + 4 - 4);
    do {
        eax22 = fun_10004bb8(ecx17, a1, v18, v19, v20, v21, v14, v13, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
        if (eax22) 
            break;
        eax27 = fun_10004c5b(a1, a1, v23, v24, v25, v26, v14);
        ecx17 = a1;
    } while (eax27);
    goto addr_100023bc_5;
    return eax22;
    addr_100023bc_5:
    zf28 = (*reinterpret_cast<unsigned char*>(&g1000de40) & 1) == 0;
    if (zf28) {
        g1000de40 = g1000de40 | 1;
        fun_1000496a(0x1000de34, ebp16 + 0xfffffffc, 1);
        g1000de34 = reinterpret_cast<int32_t>("R#");
        fun_10004ba1(0x1000de34, fun_100092fb, v29);
    }
    ecx30 = ebp16 + 0xfffffff0;
    fun_10004a59(ecx30, 0x1000de34, v31, v32, v33, "bad allocation", v14, v13);
    fun_10004c83(ecx30, ebp16 + 0xfffffff0, 0x1000c36c);
    if (v34 && (v35 = g1000e2e8, eax37 = reinterpret_cast<void**>(HeapFree(ecx30, v35, 0, v36)), !eax37)) {
        eax40 = fun_10002896(ecx30, "R#", v35, 0, v36, ebp16, "R#", v38, v39, "bad allocation", v14);
        eax41 = reinterpret_cast<void**>(GetLastError(ecx30));
        eax42 = fun_10002854(ecx30, eax41, "R#", v35, 0, v36);
        *reinterpret_cast<void***>(eax40) = eax42;
    }
    goto "R#";
}

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

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

    eax13 = fun_100029a9(ecx, a2, a3, a4, 0, reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 + 20, ebp12, __return_address(), a2);
    return eax13;
}

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

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

    eax12 = fun_10001e18(ecx, a2, a3, a4, 0);
    return eax12;
}

int32_t g1000eaf8;

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

void** fun_10002844(void** ecx);

void** fun_10009281(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12) {
    int1_t zf13;
    void** ebp14;
    void** eax15;
    void** edx16;
    void** eax17;

    zf13 = g1000eaf8 == 0;
    if (!zf13) {
        fun_1000924c(a2, 0xff, 0, ebp14, __return_address(), a2, a3, a4, a5);
        eax15 = a2;
    } else {
        eax15 = a2;
        if (eax15) {
            edx16 = eax15;
            if (*reinterpret_cast<void***>(eax15)) {
                do {
                    if (reinterpret_cast<signed char>(*reinterpret_cast<void***>(edx16)) >= reinterpret_cast<signed char>(97) && reinterpret_cast<signed char>(*reinterpret_cast<void***>(edx16)) <= reinterpret_cast<signed char>(0x7a)) {
                        *reinterpret_cast<void***>(edx16) = *reinterpret_cast<void***>(edx16) - 32;
                    }
                    ++edx16;
                } while (*reinterpret_cast<void***>(edx16));
                return eax15;
            }
        } else {
            eax17 = fun_10002896(ecx, ebp14, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
            *reinterpret_cast<void***>(eax17) = reinterpret_cast<void**>(22);
            fun_10002844(ecx);
            return 0;
        }
    }
    return eax15;
}

void** fun_10001d00(void** a1, void** a2, void** a3, void** a4, void** a5) {
    void** dl6;
    void** edi7;
    void** dh8;
    uint32_t eax9;
    uint32_t ebx10;
    uint32_t eax11;
    void** edx12;
    uint32_t ebx13;
    uint32_t ebx14;
    uint32_t ecx15;
    void* esi16;
    void* eax17;
    uint32_t eax18;
    uint32_t eax19;
    void** al20;
    void** esi21;
    void** ecx22;

    dl6 = *reinterpret_cast<void***>(a2);
    edi7 = a1;
    if (!dl6) {
        return edi7;
    }
    dh8 = *reinterpret_cast<void***>(a2 + 1);
    if (dh8) 
        goto addr_10001d18_4;
    eax9 = 0;
    *reinterpret_cast<void***>(&eax9) = dl6;
    ebx10 = eax9;
    eax11 = eax9 << 8;
    edx12 = a1;
    if (reinterpret_cast<unsigned char>(edx12) & 3) 
        goto addr_10002a48_7;
    addr_10002a5d_8:
    ebx13 = ebx10 | eax11;
    ebx14 = ebx13 << 16 | ebx13;
    while (1) {
        ecx15 = reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(edx12)) ^ ebx14;
        esi16 = reinterpret_cast<void*>(*reinterpret_cast<void***>(edx12) + 0x7efefeff);
        edx12 = edx12 + 4;
        if ((ecx15 ^ 0xffffffff ^ 0x7efefeff + ecx15) & 0x81010100) {
            eax17 = *reinterpret_cast<void**>(edx12 + 0xfffffffc);
            if (*reinterpret_cast<signed char*>(&eax17) == *reinterpret_cast<signed char*>(&ebx14)) 
                break;
            if (!*reinterpret_cast<signed char*>(&eax17)) 
                goto addr_10002aa4_12;
            if (*reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(&eax17) + 1) == *reinterpret_cast<signed char*>(&ebx14)) 
                goto addr_10002ae0_14;
            if (!*reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(&eax17) + 1)) 
                goto addr_10002aa4_12;
            eax18 = reinterpret_cast<uint32_t>(eax17) >> 16;
            if (*reinterpret_cast<signed char*>(&eax18) == *reinterpret_cast<signed char*>(&ebx14)) 
                goto addr_10002ad9_17;
            if (!*reinterpret_cast<signed char*>(&eax18)) 
                goto addr_10002aa4_12;
            if (*reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(&eax18) + 1) == *reinterpret_cast<signed char*>(&ebx14)) 
                goto addr_10002ad2_20;
            if (!*reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(&eax18) + 1)) 
                goto addr_10002aa4_12;
        } else {
            eax19 = (reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(edx12)) ^ 0xffffffff ^ reinterpret_cast<uint32_t>(esi16)) & 0x81010100;
            if (!eax19) 
                continue;
            if (eax19 & 0x1010100) 
                goto addr_10002aa4_12;
            if (!(reinterpret_cast<uint32_t>(esi16) & 0x80000000)) 
                goto addr_10002aa4_12;
        }
    }
    return edx12 + 0xfffffffc;
    addr_10002aa4_12:
    addr_10002aa6_27:
    return 0;
    addr_10002ae0_14:
    return edx12 + 0xfffffffd;
    addr_10002ad9_17:
    return edx12 + 0xfffffffe;
    addr_10002ad2_20:
    return edx12 + 0xffffffff;
    do {
        addr_10002a48_7:
        ++edx12;
        if (*reinterpret_cast<void***>(edx12) == *reinterpret_cast<void***>(&ebx10)) 
            break;
        if (!*reinterpret_cast<void***>(edx12)) 
            goto addr_10002aa6_27;
    } while (reinterpret_cast<unsigned char>(edx12) & 3);
    goto addr_10002a5d_8;
    return edx12 + 0xffffffff;
    addr_10001d38_31:
    return 0;
    addr_10001d79_32:
    return edi7 + 0xffffffff;
    while (1) {
        addr_10001d30_33:
        if (al20 == dl6) {
            do {
                al20 = *reinterpret_cast<void***>(esi21);
                ++esi21;
                if (al20 != dh8) 
                    goto addr_10001d30_33;
                edi7 = esi21 + 0xffffffff;
                do {
                    if (!*reinterpret_cast<void***>(ecx22 + 2)) 
                        goto addr_10001d79_32;
                    esi21 = esi21 + 2;
                    if (*reinterpret_cast<void***>(esi21) != *reinterpret_cast<void***>(ecx22 + 2)) 
                        goto addr_10001d18_4;
                    if (!*reinterpret_cast<void***>(ecx22 + 3)) 
                        goto addr_10001d79_32;
                    ecx22 = ecx22 + 2;
                } while (*reinterpret_cast<void***>(ecx22 + 3) == *reinterpret_cast<void***>(esi21 + 0xffffffff));
                addr_10001d18_4:
                ecx22 = a2;
                esi21 = edi7 + 1;
            } while (*reinterpret_cast<void***>(edi7) == dl6);
            if (!*reinterpret_cast<void***>(edi7)) 
                goto addr_10001d38_31;
        } else {
            if (!al20) 
                goto addr_10001d38_31;
        }
        al20 = *reinterpret_cast<void***>(esi21);
        ++esi21;
    }
}

int32_t g1000eb00;

void** fun_10005bc0(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12) {
    void** edx13;
    void** ecx14;
    void** eax15;
    int1_t zf16;
    void** edi17;
    uint32_t ecx18;
    void*** eax19;
    void** ecx20;
    uint32_t ecx21;
    void** v22;
    uint32_t eax23;
    uint32_t ebx24;
    void** v25;
    uint32_t edx26;
    uint32_t ebx27;
    uint32_t edx28;
    uint32_t eax29;
    uint32_t eax30;
    uint32_t edx31;
    uint32_t eax32;
    uint32_t edx33;
    uint32_t eax34;

    edx13 = a4;
    ecx14 = a2;
    if (!edx13) {
        return a2;
    }
    eax15 = reinterpret_cast<void**>(0);
    eax15 = a3;
    if (eax15 || (reinterpret_cast<unsigned char>(edx13) < reinterpret_cast<unsigned char>(0x80) || (zf16 = g1000eb00 == 0, zf16))) {
        edi17 = ecx14;
        if (reinterpret_cast<unsigned char>(edx13) < reinterpret_cast<unsigned char>(4)) {
            do {
                addr_10005c25_5:
                *reinterpret_cast<void***>(edi17) = eax15;
                ++edi17;
                --edx13;
            } while (edx13);
        } else {
            ecx18 = reinterpret_cast<uint32_t>(-reinterpret_cast<unsigned char>(ecx14)) & 3;
            if (ecx18) {
                edx13 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx13) - ecx18);
                do {
                    *reinterpret_cast<void***>(edi17) = eax15;
                    ++edi17;
                    --ecx18;
                } while (ecx18);
            }
            eax19 = reinterpret_cast<void***>((reinterpret_cast<unsigned char>(eax15) << 8) + reinterpret_cast<unsigned char>(eax15));
            eax15 = reinterpret_cast<void**>((reinterpret_cast<uint32_t>(eax19) << 16) + reinterpret_cast<uint32_t>(eax19));
            ecx20 = edx13;
            edx13 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx13) & 3);
            ecx21 = reinterpret_cast<unsigned char>(ecx20) >> 2;
            if (!ecx21) 
                goto addr_10005c25_5; else 
                goto addr_10005c1f_10;
        }
    } else {
        __asm__("pxor xmm0, xmm0");
        v22 = ecx14;
        eax23 = reinterpret_cast<unsigned char>(ecx14) & 15;
        if (eax23) 
            goto addr_10008272_13; else 
            goto addr_100081f3_14;
    }
    addr_10005c2f_15:
    return a2;
    addr_10005c1f_10:
    while (ecx21) {
        --ecx21;
        *reinterpret_cast<void***>(edi17) = eax15;
        edi17 = edi17 + 4;
    }
    if (!edx13) 
        goto addr_10005c2f_15; else 
        goto addr_10005c25_5;
    addr_10008272_13:
    ebx24 = -eax23 + 16;
    v25 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx13) - ebx24);
    edx26 = ebx24 & 3;
    if (edx26) {
        do {
            *reinterpret_cast<void***>(ecx14) = reinterpret_cast<void**>(0);
            ++ecx14;
            --edx26;
        } while (edx26);
    }
    ebx27 = ebx24 >> 2;
    if (ebx27) {
        do {
            *reinterpret_cast<void***>(ecx14) = reinterpret_cast<void**>(0);
            ecx14 = ecx14 + 4;
            --ebx27;
        } while (ebx27);
    }
    edx13 = v25;
    addr_100081f3_14:
    edx28 = reinterpret_cast<unsigned char>(edx13) & 0x7f;
    eax29 = reinterpret_cast<unsigned char>(edx13) >> 7;
    if (eax29) {
        do {
            __asm__("movdqa [ecx], xmm0");
            __asm__("movdqa [ecx+0x10], xmm0");
            __asm__("movdqa [ecx+0x20], xmm0");
            __asm__("movdqa [ecx+0x30], xmm0");
            __asm__("movdqa [ecx+0x40], xmm0");
            __asm__("movdqa [ecx+0x50], xmm0");
            __asm__("movdqa [ecx+0x60], xmm0");
            __asm__("movdqa [ecx+0x70], xmm0");
            ecx14 = ecx14 + 0x80;
            --eax29;
        } while (eax29);
    }
    if (edx28) {
        eax30 = edx28 >> 4;
        if (eax30) {
            do {
                __asm__("movdqa [ecx], xmm0");
                ecx14 = ecx14 + 16;
                --eax30;
            } while (eax30);
        }
        edx31 = edx28 & 15;
        if (edx31) {
            eax32 = edx31;
            edx33 = edx31 >> 2;
            if (edx33) {
                do {
                    *reinterpret_cast<void***>(ecx14) = reinterpret_cast<void**>(0);
                    ecx14 = ecx14 + 4;
                    --edx33;
                } while (edx33);
            }
            eax34 = eax32 & 3;
            if (eax34) {
                do {
                    *reinterpret_cast<void***>(ecx14) = reinterpret_cast<void**>(0);
                    ++ecx14;
                    --eax34;
                } while (eax34);
            }
        }
    }
    return v22;
}

struct s0 {
    signed char[63] pad63;
    unsigned char f63;
};

int32_t HidD_SetFeature = 0xc814;

int32_t Sleep = 0xc8e0;

int32_t HidD_GetFeature = 0xc7e8;

int32_t fun_10001070() {
    int32_t ebx1;
    int32_t v2;
    int32_t edi3;
    unsigned char cl4;
    int32_t eax5;
    int32_t esi6;
    int32_t edi7;
    struct s0* esi8;
    int32_t ebx9;
    int32_t esi10;
    int32_t edi11;
    int32_t ebx12;

    if (ebx1) {
        v2 = edi3;
        cl4 = 0;
        eax5 = esi6 + 7;
        edi7 = 10;
        do {
            eax5 = eax5 + 6;
            cl4 = reinterpret_cast<unsigned char>(cl4 ^ reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(*reinterpret_cast<unsigned char*>(eax5 - 4) ^ *reinterpret_cast<unsigned char*>(eax5 - 3)) ^ *reinterpret_cast<unsigned char*>(eax5 - 8)) ^ *reinterpret_cast<unsigned char*>(eax5 - 7)) ^ *reinterpret_cast<unsigned char*>(eax5 - 5)) ^ *reinterpret_cast<unsigned char*>(eax5 - 6)));
            --edi7;
        } while (edi7);
        esi8->f63 = cl4;
        HidD_SetFeature(ebx9, esi10, 65, v2);
        edi11 = Sleep;
        edi11(20, ebx9, esi10, 65, v2);
        HidD_GetFeature();
        edi11();
        goto ebx12;
    } else {
        return 0;
    }
}

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

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

void** fun_10008450(void** a1, void** a2, void* a3, void** a4, int32_t a5, void** a6, void** a7) {
    void** esi8;
    void* ecx9;
    void** edi10;
    int1_t zf11;
    int1_t zf12;
    uint32_t ecx13;
    uint32_t edx14;
    void** v15;
    uint32_t eax16;
    struct s1* esi17;
    struct s2* edi18;
    uint32_t ecx19;
    uint32_t edx20;
    void* eax21;
    uint32_t edx22;
    void* v23;
    uint32_t eax24;
    uint32_t ecx25;
    uint32_t eax26;
    uint32_t ecx27;
    uint32_t edx28;
    uint32_t edx29;
    uint32_t ecx30;
    uint32_t eax31;
    uint32_t ecx32;
    uint32_t ecx33;

    esi8 = a2;
    ecx9 = a3;
    edi10 = a1;
    if (reinterpret_cast<unsigned char>(edi10) <= reinterpret_cast<unsigned char>(esi8) || reinterpret_cast<unsigned char>(edi10) >= reinterpret_cast<unsigned char>(reinterpret_cast<uint32_t>(ecx9) + reinterpret_cast<unsigned char>(esi8))) {
        if (reinterpret_cast<uint32_t>(ecx9) < 0x80 || ((zf11 = g1000eb00 == 0, zf11) || (zf12 = (reinterpret_cast<unsigned char>(edi10) & 15) == (reinterpret_cast<unsigned char>(esi8) & 15), esi8 = esi8, edi10 = edi10, !zf12))) {
            if (reinterpret_cast<unsigned char>(edi10) & 3) {
                if (reinterpret_cast<uint32_t>(ecx9) < 4) {
                    goto *reinterpret_cast<int32_t*>((reinterpret_cast<uint32_t>(ecx9) - 4) * 4 + 0x100085d0);
                } else {
                    goto *reinterpret_cast<int32_t*>((reinterpret_cast<unsigned char>(edi10) & 3) * 4 + 0x100084d4);
                }
            }
            ecx13 = reinterpret_cast<uint32_t>(ecx9) >> 2;
            edx14 = reinterpret_cast<uint32_t>(ecx9) & 3;
            if (ecx13 >= 8) 
                goto addr_100084a7_8;
        } else {
            v15 = edi10;
            eax16 = reinterpret_cast<unsigned char>(esi8) & 15;
            if (eax16) 
                goto addr_10008ddb_11; else 
                goto addr_10008d1a_12;
        }
    } else {
        esi17 = reinterpret_cast<struct s1*>(reinterpret_cast<uint32_t>(ecx9) + reinterpret_cast<unsigned char>(esi8) + 0xfffffffc);
        edi18 = reinterpret_cast<struct s2*>(reinterpret_cast<uint32_t>(ecx9) + reinterpret_cast<unsigned char>(edi10) + 0xfffffffc);
        if (reinterpret_cast<uint32_t>(edi18) & 3) {
            if (reinterpret_cast<uint32_t>(ecx9) >= 4) {
                goto *reinterpret_cast<int32_t*>((reinterpret_cast<uint32_t>(edi18) & 3) * 4 + 0x10008660);
            }
            goto *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(ecx9) * 4 + 0x1000875c);
        } else {
            ecx19 = reinterpret_cast<uint32_t>(ecx9) >> 2;
            edx20 = reinterpret_cast<uint32_t>(ecx9) & 3;
            if (ecx19 < 8) {
                goto *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(-ecx19) * 4 + 0x1000870c);
                goto *reinterpret_cast<int32_t*>(edx20 * 4 + 0x1000875c);
            } else {
                while (ecx19) {
                    --ecx19;
                    edi18->f0 = esi17->f0;
                    edi18 = reinterpret_cast<struct s2*>(reinterpret_cast<uint32_t>(edi18) - 4);
                    esi17 = reinterpret_cast<struct s1*>(reinterpret_cast<uint32_t>(esi17) - 4);
                }
                goto *reinterpret_cast<int32_t*>(edx20 * 4 + 0x1000875c);
            }
        }
    }
    switch (ecx13) {
        addr_100085b7_25:
    case 0:
        switch (edx14) {
        case 0:
            return a1;
        case 1:
            *reinterpret_cast<void***>(edi10) = *reinterpret_cast<void***>(esi8);
            return a1;
        case 2:
            *reinterpret_cast<void***>(edi10) = *reinterpret_cast<void***>(esi8);
            *reinterpret_cast<void***>(edi10 + 1) = *reinterpret_cast<void***>(esi8 + 1);
            return a1;
        case 3:
            *reinterpret_cast<void***>(edi10) = *reinterpret_cast<void***>(esi8);
            *reinterpret_cast<void***>(edi10 + 1) = *reinterpret_cast<void***>(esi8 + 1);
            *reinterpret_cast<void***>(edi10 + 2) = *reinterpret_cast<void***>(esi8 + 2);
            return a1;
        }
        addr_100085a4_30:
    case 1:
        *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(edi10 + ecx13 * 4) - 4) = *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esi8 + ecx13 * 4) - 4);
        eax21 = reinterpret_cast<void*>(ecx13 * 4);
        esi8 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi8) + reinterpret_cast<uint32_t>(eax21));
        edi10 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edi10) + reinterpret_cast<uint32_t>(eax21));
        goto addr_100085b7_25;
        addr_1000859c_31:
    case 2:
        *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(edi10 + ecx13 * 4) - 8) = *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esi8 + ecx13 * 4) - 8);
        goto addr_100085a4_30;
        addr_10008594_32:
    case 3:
        *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(edi10 + ecx13 * 4) - 12) = *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esi8 + ecx13 * 4) - 12);
        goto addr_1000859c_31;
        addr_1000858c_33:
    case 4:
        *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(edi10 + ecx13 * 4) - 16) = *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esi8 + ecx13 * 4) - 16);
        goto addr_10008594_32;
        addr_10008584_34:
    case 5:
        *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(edi10 + ecx13 * 4) - 20) = *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esi8 + ecx13 * 4) - 20);
        goto addr_1000858c_33;
        addr_1000857c_35:
    case 6:
        *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(edi10 + ecx13 * 4) - 24) = *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esi8 + ecx13 * 4) - 24);
        goto addr_10008584_34;
    case 7:
        *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(edi10 + ecx13 * 4) - 28) = *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esi8 + ecx13 * 4) - 28);
        goto addr_1000857c_35;
    }
    addr_100084a7_8:
    while (ecx13) {
        --ecx13;
        *reinterpret_cast<void***>(edi10) = *reinterpret_cast<void***>(esi8);
        edi10 = edi10 + 4;
        esi8 = esi8 + 4;
    }
    goto *reinterpret_cast<int32_t*>(edx14 * 4 + 0x100085c0);
    addr_10008ddb_11:
    edx22 = 16 - eax16;
    v23 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ecx9) - edx22);
    eax24 = edx22;
    ecx25 = eax24 & 3;
    if (ecx25) {
        do {
            *reinterpret_cast<void***>(edi10) = *reinterpret_cast<void***>(esi8);
            ++esi8;
            ++edi10;
            --ecx25;
        } while (ecx25);
    }
    eax26 = eax24 >> 2;
    if (eax26) {
        do {
            *reinterpret_cast<void***>(edi10) = *reinterpret_cast<void***>(esi8);
            esi8 = esi8 + 4;
            edi10 = edi10 + 4;
            --eax26;
        } while (eax26);
    }
    ecx9 = v23;
    addr_10008d1a_12:
    ecx27 = reinterpret_cast<uint32_t>(ecx9) & 0x7f;
    edx28 = reinterpret_cast<uint32_t>(ecx9) >> 7;
    if (edx28) {
        do {
            __asm__("movdqa xmm0, [esi]");
            __asm__("movdqa xmm1, [esi+0x10]");
            __asm__("movdqa xmm2, [esi+0x20]");
            __asm__("movdqa xmm3, [esi+0x30]");
            __asm__("movdqa [edi], xmm0");
            __asm__("movdqa [edi+0x10], xmm1");
            __asm__("movdqa [edi+0x20], xmm2");
            __asm__("movdqa [edi+0x30], xmm3");
            __asm__("movdqa xmm4, [esi+0x40]");
            __asm__("movdqa xmm5, [esi+0x50]");
            __asm__("movdqa xmm6, [esi+0x60]");
            __asm__("movdqa xmm7, [esi+0x70]");
            __asm__("movdqa [edi+0x40], xmm4");
            __asm__("movdqa [edi+0x50], xmm5");
            __asm__("movdqa [edi+0x60], xmm6");
            __asm__("movdqa [edi+0x70], xmm7");
            esi8 = esi8 + 0x80;
            edi10 = edi10 + 0x80;
            --edx28;
        } while (edx28);
    }
    if (ecx27) {
        edx29 = ecx27 >> 4;
        if (edx29) {
            do {
                __asm__("movdqa xmm0, [esi]");
                __asm__("movdqa [edi], xmm0");
                esi8 = esi8 + 16;
                edi10 = edi10 + 16;
                --edx29;
            } while (edx29);
        }
        ecx30 = ecx27 & 15;
        if (ecx30) {
            eax31 = ecx30;
            ecx32 = ecx30 >> 2;
            if (ecx32) {
                do {
                    *reinterpret_cast<void***>(edi10) = *reinterpret_cast<void***>(esi8);
                    esi8 = esi8 + 4;
                    edi10 = edi10 + 4;
                    --ecx32;
                } while (ecx32);
            }
            ecx33 = eax31 & 3;
            if (ecx33) {
                do {
                    *reinterpret_cast<void***>(edi10) = *reinterpret_cast<void***>(esi8);
                    ++esi8;
                    ++edi10;
                    --ecx33;
                } while (ecx33);
            }
        }
    }
    return v15;
    return a1;
    *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(edi18) + 3) = *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(esi17) + 3);
    return a1;
    *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(edi18) + 3) = *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(esi17) + 3);
    *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(edi18) + 2) = *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(esi17) + 2);
    return a1;
    *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(edi18) + 3) = *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(esi17) + 3);
    *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(edi18) + 2) = *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(esi17) + 2);
    *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(edi18) + 1) = *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(esi17) + 1);
    return a1;
}

void** fun_100010d0(void** ecx, int32_t a2, void** a3, void* a4, int32_t a5, void** a6) {
    void* ebp7;
    void** eax8;
    void** edi9;
    void** ebx10;
    void** v11;
    void** v12;
    void** v13;
    void** v14;
    void** v15;
    void** v16;
    void* v17;
    int32_t esi18;
    int32_t edi19;
    void** v20;
    void** ecx21;
    void** eax22;

    ebp7 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    eax8 = g1000d050;
    fun_10005bc0(ecx, reinterpret_cast<uint32_t>(ebp7) + 0xffffffb8, 0, 65, edi9, ebx10, v11, v12, v13, v14, v15, v16);
    v17 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ebp7) + 0xffffffb8);
    HidD_SetFeature(esi18, v17, 65, edi9, ebx10, 0, 0x83013a);
    edi19 = Sleep;
    edi19(1, esi18, v17, 65, edi9, ebx10, 0, 0x83013a);
    v20 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp7) + 0xffffffb8);
    HidD_GetFeature();
    edi19();
    ecx21 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax8) ^ reinterpret_cast<uint32_t>(ebp7) ^ reinterpret_cast<uint32_t>(ebp7));
    eax22 = fun_10001cc4(ecx21, v20, ecx21, v20);
    return eax22;
}

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

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

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

    eax11 = fun_10003644(ecx, esi10, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
    if (!eax11) {
        fun_10003e6f(ecx, 16);
    }
    return eax11;
}

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

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

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

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

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

void fun_10003501(void** ecx);

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

void** fun_10003494(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
    void** eax8;
    void** eax9;
    int32_t ebp10;
    void** v11;
    void** esi12;
    void** eax13;
    int32_t ebp14;
    int32_t ebp15;
    void** eax16;

    fun_10004570(0x1000c400, 12, __return_address());
    eax8 = fun_100036bd(ecx, 0x1000c400, 12, __return_address(), a2, a3, a4, a5, a6);
    eax9 = g1000d6f0;
    if (!(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(eax8 + 0x70)) & reinterpret_cast<unsigned char>(eax9)) || !*reinterpret_cast<void***>(eax8 + 0x6c)) {
        fun_10006df1(ecx, 12, 0x1000c400, 12, __return_address(), a2, a3, a4, a5, a6, a7);
        *reinterpret_cast<uint32_t*>(ebp10 - 4) = 0;
        v11 = image_base_;
        esi12 = eax8 + 0x6c;
        eax13 = fun_10003447(12, esi12, v11, 0x1000c400, 12, __return_address(), a2, a3);
        ecx = v11;
        *reinterpret_cast<void***>(ebp14 - 28) = eax13;
        *reinterpret_cast<int32_t*>(ebp15 - 4) = -2;
        fun_10003501(ecx);
    } else {
        eax16 = fun_100036bd(ecx, 0x1000c400, 12, __return_address(), a2, a3, a4, a5, a6);
        esi12 = *reinterpret_cast<void***>(eax16 + 0x6c);
    }
    if (!esi12) {
        fun_10003e6f(ecx, 32);
        ecx = reinterpret_cast<void**>(32);
    }
    fun_100045b5(ecx, 0x1000c400, 12, __return_address(), a2, a3);
    goto 0x1000c400;
}

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

int32_t InterlockedDecrement = 0xca18;

int32_t InterlockedIncrement = 0xca00;

void fun_10002dac(void** ecx);

void** fun_10002d11(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14) {
    void** eax15;
    void** eax16;
    int32_t ebp17;
    void** esi18;
    int32_t ebp19;
    int1_t zf20;
    int32_t eax21;
    void** eax22;
    int32_t ebp23;
    int32_t ebp24;

    fun_10004570(0x1000c3c0, 12, __return_address());
    eax15 = fun_100036bd(ecx, 0x1000c3c0, 12, __return_address(), a2, a3, a4, a5, a6);
    eax16 = g1000d6f0;
    if (!(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(eax15 + 0x70)) & reinterpret_cast<unsigned char>(eax16)) || !*reinterpret_cast<void***>(eax15 + 0x6c)) {
        fun_10006df1(ecx, 13, 0x1000c3c0, 12, __return_address(), a2, a3, a4, a5, a6, a7);
        ecx = reinterpret_cast<void**>(13);
        *reinterpret_cast<uint32_t*>(ebp17 - 4) = 0;
        esi18 = *reinterpret_cast<void***>(eax15 + 0x68);
        *reinterpret_cast<void***>(ebp19 - 28) = esi18;
        zf20 = esi18 == image_base_;
        if (!zf20) {
            if (esi18 && ((eax21 = reinterpret_cast<int32_t>(InterlockedDecrement(13, esi18)), !eax21) && esi18 != 0x1000d1d0)) {
                fun_10002416(13, esi18, esi18, 0x1000c3c0, 12, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
                ecx = esi18;
            }
            eax22 = image_base_;
            *reinterpret_cast<void***>(eax15 + 0x68) = eax22;
            esi18 = image_base_;
            *reinterpret_cast<void***>(ebp23 - 28) = esi18;
            InterlockedIncrement(ecx, esi18);
        }
        *reinterpret_cast<int32_t*>(ebp24 - 4) = -2;
        fun_10002dac(ecx);
    } else {
        esi18 = *reinterpret_cast<void***>(eax15 + 0x68);
    }
    if (!esi18) {
        fun_10003e6f(ecx, 32);
        ecx = reinterpret_cast<void**>(32);
    }
    fun_100045b5(ecx, 0x1000c3c0, 12, __return_address(), a2, a3);
    goto 0x1000c3c0;
}

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

    eax12 = fun_10003644(ecx, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10);
    if (eax12) {
        return eax12 + 8;
    } else {
        return 0x1000d1c8;
    }
}

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

void** fun_10002844(void** ecx) {
    void** eax2;

    eax2 = fun_10002817(ecx, 0, 0, 0, 0, 0);
    return eax2;
}

void fun_10001cb9(void** ecx, void** a2, void** a3, void** a4, void** a5) {
    void** v6;
    void** eax7;
    void** esi8;
    void** ebp9;
    void** eax10;
    void** eax11;
    void** eax12;

    if (a2 && (v6 = g1000e2e8, eax7 = reinterpret_cast<void**>(HeapFree(ecx, v6, 0, a2)), !eax7)) {
        eax10 = fun_10002896(ecx, esi8, v6, 0, a2, ebp9, __return_address(), a2, a3, a4, a5);
        eax11 = reinterpret_cast<void**>(GetLastError(ecx));
        eax12 = fun_10002854(ecx, eax11, esi8, v6, 0, a2);
        *reinterpret_cast<void***>(eax10) = eax12;
    }
    return;
}

struct s3 {
    signed char[12] pad12;
    void** f12;
};

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

int32_t fun_1000351f();

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

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

void** g1000e194;

int32_t DecodePointer = 0xc940;

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

int32_t GetCurrentThreadId = 0xc92a;

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

void** g1000e1d4;

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

struct s4 {
    signed char[16] pad16;
    void** f16;
};

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

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

void fun_10004557(void** ecx);

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

int32_t fun_10004539();

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

void fun_100044ed();

int32_t GetCommandLineA = 0xc950;

void** g1000fc58;

void** fun_10004456(void** ecx);

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

uint32_t fun_10003e8d(void** ecx);

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

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

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

uint32_t fun_100020ca(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13) {
    struct s3* ebp14;
    void** eax15;
    void** v16;
    void** v17;
    int32_t eax18;
    int32_t eax19;
    void** eax20;
    int1_t less_or_equal21;
    int32_t ebp22;
    int1_t zf23;
    struct s4* ebp24;
    int32_t ebp25;
    int32_t eax26;
    int32_t eax27;
    void** eax28;
    void** eax29;
    uint32_t eax30;
    uint32_t eax31;
    uint32_t eax32;
    int32_t eax33;

    fun_10004570(0x1000c330, 8, __return_address());
    if (!reinterpret_cast<int1_t>(ebp14->f12 == 1)) {
        if (ebp14->f12) {
            if (!reinterpret_cast<int1_t>(ebp14->f12 == 2)) {
                if (reinterpret_cast<int1_t>(ebp14->f12 == 3)) {
                    fun_10003806(ecx, 0, 0x1000c330, 8, __return_address(), a2, a3, a4, a5);
                    ecx = reinterpret_cast<void**>(0);
                }
            } else {
                fun_1000351f();
                eax15 = fun_10003b2d(ecx, 1, 0x214, 0x1000c330, 8, __return_address(), a2, a3, a4, a5, a6);
                ecx = reinterpret_cast<void**>(0x214);
                if (!eax15) {
                    addr_100020e7_7:
                    goto addr_10002226_8;
                } else {
                    v16 = g1000d93c;
                    v17 = g1000e194;
                    eax18 = reinterpret_cast<int32_t>(DecodePointer(0x214, v17, v16, eax15));
                    eax19 = reinterpret_cast<int32_t>(eax18(0x214, v17, v16, eax15));
                    if (!eax19) {
                        fun_10002416(0x214, eax15, v17, v16, eax15, 0x1000c330, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
                        ecx = eax15;
                        goto addr_100020e7_7;
                    } else {
                        fun_10003590(0x214, eax15, 0, v17, v16, eax15, 0x1000c330, 8, __return_address(), a2, a3, a4, a5, a6);
                        ecx = reinterpret_cast<void**>(0);
                        eax20 = reinterpret_cast<void**>(GetCurrentThreadId(0, v17, v16, eax15));
                        *reinterpret_cast<void***>(eax15) = eax20;
                        *reinterpret_cast<void***>(eax15 + 4) = reinterpret_cast<void**>(0xffffffff);
                    }
                }
            }
        } else {
            less_or_equal21 = reinterpret_cast<signed char>(g1000de20) <= reinterpret_cast<signed char>(0);
            if (less_or_equal21) 
                goto addr_100020e7_7;
            --g1000de20;
            *reinterpret_cast<void***>(ebp22 - 4) = reinterpret_cast<void**>(0);
            zf23 = g1000e1d4 == 0;
            if (zf23) {
                fun_10003e60(ecx, 0x1000c330, 8, __return_address());
            }
            if (!ebp24->f16) {
                fun_100040d2(ecx, 0x1000c330, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
                fun_10003553(ecx, 0x1000c330, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
                fun_10004557(ecx);
            }
            *reinterpret_cast<int32_t*>(ebp25 - 4) = -2;
            fun_100021a3(ecx, 0x1000c330, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
        }
    } else {
        eax26 = fun_10004539();
        if (!eax26) 
            goto addr_100020e7_7;
        eax27 = fun_10003874(ecx, 0x1000c330, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10);
        if (eax27) 
            goto addr_100020fe_20; else 
            goto addr_100020f7_21;
    }
    addr_10002223_22:
    addr_10002226_8:
    fun_100045b5(ecx, 0x1000c330, 8, __return_address(), a2, a3);
    goto 0x1000c330;
    addr_100020fe_20:
    fun_100044ed();
    eax28 = reinterpret_cast<void**>(GetCommandLineA());
    g1000fc58 = eax28;
    eax29 = fun_10004456(ecx);
    g1000de24 = eax29;
    eax30 = fun_10003e8d(ecx);
    if (reinterpret_cast<int32_t>(eax30) >= reinterpret_cast<int32_t>(0)) {
        eax31 = fun_1000439b(ecx, 0x1000c330, 8, __return_address(), a2);
        if (reinterpret_cast<int32_t>(eax31) < reinterpret_cast<int32_t>(0) || ((eax32 = fun_10004125(ecx, 0x1000c330, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11), reinterpret_cast<int32_t>(eax32) < reinterpret_cast<int32_t>(0)) || (eax33 = fun_10003c73(ecx, 0), ecx = reinterpret_cast<void**>(0), !!eax33))) {
            fun_100040d2(ecx, 0x1000c330, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
            goto addr_10002121_25;
        } else {
            ++g1000de20;
            goto addr_10002223_22;
        }
    } else {
        addr_10002121_25:
        fun_10003553(ecx, 0x1000c330, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
    }
    addr_100020f7_21:
    fun_10004557(ecx);
    goto addr_100020e7_7;
}

int32_t HeapCreate = 0xcb9a;

int32_t fun_10004539() {
    void** eax1;

    eax1 = reinterpret_cast<void**>(HeapCreate());
    g1000e2e8 = eax1;
    goto 0;
}

int32_t HeapDestroy = 0xcba8;

void fun_10004557(void** ecx) {
    void** v2;

    v2 = g1000e2e8;
    HeapDestroy();
    g1000e2e8 = reinterpret_cast<void**>(0);
    goto v2;
}

void** g1000e198;

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

void** TlsFree = reinterpret_cast<void**>(0x80);

int32_t DeleteCriticalSection = 0xcb38;

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

struct s6 {
    int32_t f0;
    int32_t f4;
};

void fun_10003553(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void** a16) {
    void** v17;
    void** eax18;
    void** v19;
    int32_t eax20;
    void** eax21;
    void** v22;
    void** ebx23;
    int32_t ebx24;
    void** v25;
    void** esi26;
    struct s5* esi27;
    void** v28;
    void** edi29;
    void** edi30;
    struct s6* esi31;
    int32_t v32;

    v17 = reinterpret_cast<void**>(__return_address());
    eax18 = g1000d93c;
    if (eax18 != 0xffffffff) {
        v19 = g1000e198;
        eax20 = reinterpret_cast<int32_t>(DecodePointer(v19, eax18));
        eax20(v19, eax18);
        g1000d93c = reinterpret_cast<void**>(0xffffffff);
    }
    eax21 = g1000d940;
    if (eax21 != 0xffffffff) {
        TlsFree(eax21);
        g1000d940 = reinterpret_cast<void**>(0xffffffff);
    }
    v22 = ebx23;
    ebx24 = DeleteCriticalSection;
    v25 = esi26;
    esi27 = reinterpret_cast<struct s5*>(0x1000dc40);
    v28 = edi29;
    do {
        edi30 = esi27->f0;
        if (edi30 && esi27->f4 != 1) {
            ebx24(ecx, edi30);
            fun_10002416(ecx, edi30, edi30, v28, v25, v22, v17, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
            esi27->f0 = reinterpret_cast<void**>(0);
            ecx = edi30;
        }
        ++esi27;
    } while (reinterpret_cast<int32_t>(esi27) < reinterpret_cast<int32_t>("."));
    esi31 = reinterpret_cast<struct s6*>(0x1000dc40);
    do {
        if (esi31->f0 && esi31->f4 == 1) {
            v32 = esi31->f0;
            ebx24(ecx, v32);
        }
        ++esi31;
    } while (reinterpret_cast<int32_t>(esi31) < reinterpret_cast<int32_t>("."));
    return;
}

void** g1000fc4c;

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

struct s7 {
    signed char[1] pad1;
    void** f1;
};

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

void** g1000e1b8;

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

int32_t g1000fc40;

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

void** g0;

uint32_t fun_10007c0d(void** a1);

uint32_t fun_10004125(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14) {
    void** v15;
    int1_t zf16;
    void** v17;
    void** esi18;
    void** esi19;
    void** v20;
    void** edi21;
    struct s7* edi22;
    void** eax23;
    void** eax24;
    void** edi25;
    void** ecx26;
    uint32_t eax27;
    void** esi28;
    void** v29;
    void** ebx30;
    void** eax31;
    void** ebx32;
    void** eax33;
    void** eax34;
    void** v35;
    void** v36;
    void** v37;
    void** edi38;
    void*** esi39;
    void*** edx40;
    void** edx41;
    void** v42;
    void** bl43;
    uint32_t eax44;
    void** ecx45;
    void** al46;
    void** eax47;
    uint32_t v48;
    void** eax49;
    int32_t ebx50;
    uint32_t ecx51;
    void*** eax52;
    uint32_t eax53;
    void** v54;
    uint32_t eax55;
    uint32_t eax56;
    void** al57;
    void** ecx58;
    void** ecx59;
    void** al60;

    v15 = reinterpret_cast<void**>(__return_address());
    zf16 = g1000fc4c == 0;
    if (zf16) {
        fun_100031b6(ecx, v15, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
    }
    v17 = esi18;
    esi19 = g1000de24;
    v20 = edi21;
    edi22 = reinterpret_cast<struct s7*>(0);
    if (esi19) {
        while (*reinterpret_cast<void***>(esi19)) {
            if (*reinterpret_cast<void***>(esi19) != 61) {
                edi22 = reinterpret_cast<struct s7*>(&edi22->f1);
            }
            eax23 = fun_100058d0(esi19, v20, v17, v15, a2, a3, esi19, v20, v17, v15, a2, a3);
            ecx = esi19;
            esi19 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi19) + reinterpret_cast<unsigned char>(eax23) + 1);
        }
        eax24 = fun_10003b2d(ecx, &edi22->f1, 4, v20, v17, v15, a2, a3, a4, a5, a6);
        edi25 = eax24;
        ecx26 = reinterpret_cast<void**>(4);
        g1000e1b8 = edi25;
        if (!edi25) 
            goto addr_10004141_9;
    } else {
        addr_10004141_9:
        eax27 = 0xffffffff;
        goto addr_100041da_10;
    }
    esi28 = g1000de24;
    v29 = ebx30;
    while (*reinterpret_cast<void***>(esi28)) {
        eax31 = fun_100058d0(esi28, v29, v20, v17, v15, a2, esi28, v29, v20, v17, v15, a2);
        ecx26 = esi28;
        ebx32 = eax31 + 1;
        if (*reinterpret_cast<void***>(esi28) != 61) {
            eax33 = fun_10003b2d(ecx26, ebx32, 1, v29, v20, v17, v15, a2, a3, a4, a5);
            ecx26 = reinterpret_cast<void**>(1);
            *reinterpret_cast<void***>(edi25) = eax33;
            if (!eax33) 
                goto addr_100041dd_15;
            eax34 = fun_10007302(1, eax33, ebx32, esi28, v29, v20, v17);
            if (eax34) 
                goto addr_100041f4_17;
            edi25 = edi25 + 4;
        }
        esi28 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi28) + reinterpret_cast<unsigned char>(ebx32));
    }
    v35 = g1000de24;
    fun_10002416(ecx26, v35, v29, v20, v17, v15, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
    g1000de24 = reinterpret_cast<void**>(0);
    *reinterpret_cast<void***>(edi25) = reinterpret_cast<void**>(0);
    g1000fc40 = 1;
    eax27 = 0;
    addr_100041d8_21:
    addr_100041da_10:
    return eax27;
    addr_100041dd_15:
    v35 = g1000e1b8;
    fun_10002416(1, v35, v29, v20, v17, v15, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
    g1000e1b8 = reinterpret_cast<void**>(0);
    eax27 = 0xffffffff;
    goto addr_100041d8_21;
    addr_100041f4_17:
    v36 = reinterpret_cast<void**>(0);
    v37 = reinterpret_cast<void**>(0);
    fun_100027f2(1, 0, 0, 0, 0, 0);
    edi38 = edi25;
    *reinterpret_cast<void***>(edi38) = reinterpret_cast<void**>(0);
    esi39 = edx40;
    edx41 = reinterpret_cast<void**>(0);
    g0 = reinterpret_cast<void**>(1);
    if (!1) {
        v37 = reinterpret_cast<void**>(4);
        g0 = reinterpret_cast<void**>(0);
    }
    v42 = reinterpret_cast<void**>(0);
    do {
        if (!reinterpret_cast<int1_t>(*esi39 == 34)) {
            *reinterpret_cast<void***>(edi38) = *reinterpret_cast<void***>(edi38) + 1;
            if (edx41) {
                *reinterpret_cast<void***>(edx41) = *esi39;
                v36 = edx41 + 1;
            }
            bl43 = *esi39;
            ++esi39;
            eax44 = fun_10007c0d(static_cast<uint32_t>(reinterpret_cast<unsigned char>(bl43)));
            if (eax44) {
                *reinterpret_cast<void***>(edi38) = *reinterpret_cast<void***>(edi38) + 1;
                if (v36) {
                    ecx45 = v36;
                    al46 = *esi39;
                    ++v36;
                    *reinterpret_cast<void***>(ecx45) = al46;
                }
                ++esi39;
            }
            edx41 = v36;
            if (!bl43) 
                break;
        } else {
            eax47 = reinterpret_cast<void**>(0);
            bl43 = reinterpret_cast<void**>(34);
            *reinterpret_cast<unsigned char*>(&eax47) = reinterpret_cast<uint1_t>(v42 == 0);
            ++esi39;
            v42 = eax47;
        }
    } while (v42 || bl43 != 32 && !reinterpret_cast<int1_t>(bl43 == 9));
    goto addr_1000428d_35;
    --esi39;
    addr_10004295_37:
    v48 = 0;
    while (*esi39) {
        while (*esi39 == 32 || reinterpret_cast<int1_t>(*esi39 == 9)) {
            ++esi39;
        }
        if (!*esi39) 
            break;
        if (v37) {
            eax49 = v37;
            v37 = v37 + 4;
            *reinterpret_cast<void***>(eax49) = edx41;
        }
        ++g0;
        while (1) {
            ebx50 = 1;
            ecx51 = 0;
            while (*esi39 == 92) {
                ++esi39;
                ++ecx51;
            }
            if (reinterpret_cast<int1_t>(*esi39 == 34)) {
                if (!(*reinterpret_cast<unsigned char*>(&ecx51) & 1)) {
                    if (!v48 || (eax52 = esi39 + 1, !reinterpret_cast<int1_t>(*eax52 == 34))) {
                        eax53 = 0;
                        ebx50 = 0;
                        *reinterpret_cast<unsigned char*>(&eax53) = reinterpret_cast<uint1_t>(v48 == 0);
                        v48 = eax53;
                    } else {
                        esi39 = eax52;
                    }
                }
                ecx51 = ecx51 >> 1;
            }
            if (ecx51) {
                do {
                    --ecx51;
                    if (edx41) {
                        *reinterpret_cast<void***>(edx41) = reinterpret_cast<void**>(92);
                        ++edx41;
                    }
                    *reinterpret_cast<void***>(edi38) = *reinterpret_cast<void***>(edi38) + 1;
                } while (ecx51);
                v36 = edx41;
            }
            if (!*esi39) 
                break;
            if (v48) 
                goto addr_1000432f_61;
            if (*esi39 == 32) 
                break;
            if (*esi39 == 9) 
                break;
            addr_1000432f_61:
            if (ebx50) {
                v54 = reinterpret_cast<void**>(static_cast<int32_t>(reinterpret_cast<signed char>(*esi39)));
                if (!edx41) {
                    eax55 = fun_10007c0d(v54);
                    if (eax55) {
                        ++esi39;
                        *reinterpret_cast<void***>(edi38) = *reinterpret_cast<void***>(edi38) + 1;
                    }
                } else {
                    eax56 = fun_10007c0d(v54);
                    if (eax56) {
                        al57 = *esi39;
                        ecx58 = v36;
                        ++v36;
                        *reinterpret_cast<void***>(ecx58) = al57;
                        ++esi39;
                        *reinterpret_cast<void***>(edi38) = *reinterpret_cast<void***>(edi38) + 1;
                    }
                    ecx59 = v36;
                    al60 = *esi39;
                    ++v36;
                    *reinterpret_cast<void***>(ecx59) = al60;
                }
                *reinterpret_cast<void***>(edi38) = *reinterpret_cast<void***>(edi38) + 1;
                edx41 = v36;
            }
            ++esi39;
        }
        if (edx41) {
            *reinterpret_cast<void***>(edx41) = reinterpret_cast<void**>(0);
            ++edx41;
            v36 = edx41;
        }
        *reinterpret_cast<void***>(edi38) = *reinterpret_cast<void***>(edi38) + 1;
    }
    if (v37) {
        *reinterpret_cast<void***>(v37) = reinterpret_cast<void**>(0);
    }
    ++g0;
    goto 0;
    addr_1000428d_35:
    if (edx41) {
        *reinterpret_cast<void***>(edx41 + 0xffffffff) = reinterpret_cast<void**>(0);
        goto addr_10004295_37;
    }
}

int32_t g1000fc50;

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

void fun_10005891(void** ecx);

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

void fun_10004513();

int32_t g1000fc54;

int32_t fun_10003c73(void** ecx, void** a2) {
    int1_t zf3;
    uint32_t eax4;
    int32_t eax5;
    void** edi6;
    int32_t* edi7;
    int32_t eax8;
    int1_t zf9;
    uint32_t eax10;

    zf3 = g1000fc50 == 0;
    if (!zf3 && (eax4 = fun_100078f0(ecx, 0x1000fc50), ecx = reinterpret_cast<void**>(0x1000fc50), !!eax4)) {
        g1000fc50(0x1000fc50);
        ecx = a2;
    }
    fun_10005891(ecx);
    eax5 = fun_10003c4f(ecx, 0x1000a13c, 0x1000a150);
    if (!eax5) {
        fun_10004ba1(0x1000a150, fun_10004513, edi6);
        edi7 = reinterpret_cast<int32_t*>(0x1000a134);
        if (!0) {
            do {
                eax8 = *edi7;
                if (eax8) {
                    eax8(fun_10004513);
                }
                ++edi7;
            } while (reinterpret_cast<uint32_t>(edi7) < 0x1000a138);
        }
        zf9 = g1000fc54 == 0;
        if (!zf9 && (eax10 = fun_100078f0(fun_10004513, 0x1000fc54), !!eax10)) {
            g1000fc54(0x1000fc54, 0, 2, 0);
        }
        eax5 = 0;
    }
    return eax5;
}

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

void** fun_10003e60(void** ecx, void** a2, void** a3, void** a4) {
    void** eax5;

    eax5 = fun_10003d0a(ecx, 0, 0, 1, __return_address(), a2, a3);
    return eax5;
}

void** fun_100040d2(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15) {
    void** v16;
    void** v17;
    void** esi18;
    void** v19;
    void** edi20;
    void*** edi21;
    void** eax22;
    void** ecx23;
    void*** esi24;
    void** v25;

    v16 = reinterpret_cast<void**>(__return_address());
    v17 = esi18;
    v19 = edi20;
    edi21 = reinterpret_cast<void***>(0x1000fb40);
    do {
        eax22 = *edi21;
        if (eax22) {
            ecx23 = eax22 + 0x800;
            if (reinterpret_cast<unsigned char>(eax22) < reinterpret_cast<unsigned char>(ecx23)) {
                esi24 = reinterpret_cast<void***>(eax22 + 12);
                do {
                    if (*reinterpret_cast<int32_t*>(esi24 + 0xfffffffc)) {
                        DeleteCriticalSection(esi24);
                    }
                    esi24 = esi24 + 64;
                    ecx23 = reinterpret_cast<void**>(esi24 + 0xfffffff4);
                } while (reinterpret_cast<unsigned char>(ecx23) < reinterpret_cast<unsigned char>(*edi21 + 0x800));
            }
            v25 = *edi21;
            eax22 = fun_10002416(ecx23, v25, v19, v17, v16, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            *edi21 = reinterpret_cast<void**>(0);
        }
        edi21 = edi21 + 4;
    } while (reinterpret_cast<int32_t>(edi21) < 0x1000fc40);
    return eax22;
}

struct s8 {
    signed char[16] pad16;
    int32_t f16;
};

void fun_100021a3(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15) {
    struct s8* ebp16;
    int32_t edi17;
    int1_t zf18;

    if (ebp16->f16 == edi17 && (zf18 = reinterpret_cast<int1_t>(g1000d93c == 0xffffffff), !zf18)) {
        fun_10003553(ecx, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
    }
    return;
}

void** TlsGetValue = reinterpret_cast<void**>(100);

void** g1000e190;

void** TlsSetValue = reinterpret_cast<void**>(0x72);

int32_t fun_1000351f() {
    int32_t eax1;
    void** v2;
    int32_t eax3;
    void** v4;
    int32_t esi5;

    eax1 = reinterpret_cast<int32_t>(TlsGetValue());
    if (!eax1) {
        v2 = g1000e190;
        eax3 = reinterpret_cast<int32_t>(DecodePointer(v2));
        v4 = g1000d940;
        TlsSetValue(v4, eax3, v2);
    }
    goto esi5;
}

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

void** g1000e1a4;

void** fun_10003b2d(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11) {
    void** v12;
    void** v13;
    void** ebp14;
    void** v15;
    void** esi16;
    void** v17;
    void** edi18;
    void** esi19;
    void** eax20;
    int1_t below_or_equal21;
    void** eax22;
    int1_t below_or_equal23;

    v12 = reinterpret_cast<void**>(__return_address());
    v13 = ebp14;
    v15 = esi16;
    v17 = edi18;
    esi19 = reinterpret_cast<void**>(0);
    do {
        eax20 = fun_100074c2(a2, a3, 0, v17, v15, v13, v12, a2);
        if (eax20) 
            break;
        below_or_equal21 = reinterpret_cast<unsigned char>(g1000e1a4) <= reinterpret_cast<unsigned char>(eax20);
        if (below_or_equal21) 
            break;
        Sleep(esi19);
        eax22 = esi19 + 0x3e8;
        below_or_equal23 = reinterpret_cast<unsigned char>(eax22) <= reinterpret_cast<unsigned char>(g1000e1a4);
        if (!below_or_equal23) {
            eax22 = reinterpret_cast<void**>(0xffffffff);
        }
        esi19 = eax22;
    } while (!reinterpret_cast<int1_t>(eax22 == 0xffffffff));
    return eax20;
}

int32_t GetModuleHandleW = 0xca8a;

struct s9 {
    signed char[8] pad8;
    uint32_t f8;
    signed char[8] pad20;
    int32_t f20;
    signed char[68] pad92;
    int32_t f92;
    signed char[8] pad104;
    void** f104;
    signed char[3] pad108;
    void** f108;
    signed char[3] pad112;
    int32_t f112;
    signed char[84] pad200;
    signed char f200;
    signed char[130] pad331;
    signed char f331;
};

struct s10 {
    signed char[8] pad8;
    struct s9* f8;
};

void fun_10003632(void** ecx);

struct s11 {
    signed char[12] pad12;
    void** f12;
};

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

void fun_1000363b(void** ecx);

void fun_10003590(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14) {
    struct s9* esi15;
    struct s10* ebp16;
    int32_t ebp17;
    void** v18;
    int32_t ebp19;
    int32_t ebp20;
    void** eax21;
    struct s11* ebp22;
    void** eax23;
    void** v24;
    int32_t ebp25;

    fun_10004570(0x1000c420, 8, __return_address());
    GetModuleHandleW("K", 0x1000c420, 8, __return_address());
    esi15 = ebp16->f8;
    esi15->f92 = 0x1000a5f8;
    esi15->f8 = 0;
    esi15->f20 = 1;
    esi15->f112 = 1;
    esi15->f200 = 67;
    esi15->f331 = 67;
    esi15->f104 = reinterpret_cast<void**>(0x1000d1d0);
    fun_10006df1(ecx, 13, "K", 0x1000c420, 8, __return_address(), a2, a3, a4, a5, a6);
    *reinterpret_cast<uint32_t*>(ebp17 - 4) = 0;
    v18 = esi15->f104;
    InterlockedIncrement(13);
    *reinterpret_cast<int32_t*>(ebp19 - 4) = -2;
    fun_10003632(13);
    fun_10006df1(13, 12, v18, "K", 0x1000c420, 8, __return_address(), a2, a3, a4, a5);
    *reinterpret_cast<int32_t*>(ebp20 - 4) = 1;
    eax21 = ebp22->f12;
    esi15->f108 = eax21;
    if (!eax21) {
        eax23 = image_base_;
        esi15->f108 = eax23;
    }
    v24 = esi15->f108;
    fun_100031d4(12, v24);
    *reinterpret_cast<int32_t*>(ebp25 - 4) = -2;
    fun_1000363b(v24);
    fun_100045b5(v24, v18, "K", 0x1000c420, 8, __return_address());
    goto v18;
}

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

void fun_10003806(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9) {
    int1_t zf10;
    void** esi11;
    int32_t eax12;
    void** v13;
    void** v14;
    int32_t eax15;
    void** eax16;
    void** v17;
    void** v18;
    int32_t eax19;
    void** ebp20;
    void** eax21;

    zf10 = reinterpret_cast<int1_t>(g1000d93c == 0xffffffff);
    if (!zf10) {
        if (!a2) {
            esi11 = TlsGetValue;
            eax12 = reinterpret_cast<int32_t>(esi11());
            if (eax12) {
                v13 = g1000d93c;
                v14 = g1000d940;
                eax15 = reinterpret_cast<int32_t>(esi11(v14, v13));
                eax16 = reinterpret_cast<void**>(eax15(v14, v13));
                a2 = eax16;
            }
        }
        v17 = g1000d93c;
        v18 = g1000e194;
        eax19 = reinterpret_cast<int32_t>(DecodePointer(v18, v17, 0));
        eax19(v18, v17, 0);
        fun_100036d7(ecx, a2, v18, v17, 0, ebp20, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
    }
    eax21 = g1000d940;
    if (eax21 != 0xffffffff) {
        TlsSetValue(eax21, 0);
    }
    return;
}

void** fun_100048c9(void** a1, void** a2, void** a3) {
    return 1;
}

int32_t GetSystemTimeAsFileTime = 0xcbf6;

int32_t GetCurrentProcessId = 0xcbe0;

int32_t GetTickCount = 0xcbd0;

int32_t QueryPerformanceCounter = 0xcbb6;

void fun_100048cf() {
    void** eax1;
    void* v2;
    int32_t esi3;
    uint32_t eax4;
    uint32_t eax5;
    uint32_t eax6;
    void** esi7;
    uint32_t v8;
    uint32_t v9;

    eax1 = g1000d050;
    if (eax1 == 0xbb40e64e || !(0xffff0000 & reinterpret_cast<unsigned char>(eax1))) {
        v2 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 - 8);
        GetSystemTimeAsFileTime(v2, esi3);
        eax4 = reinterpret_cast<uint32_t>(GetCurrentProcessId(v2, esi3));
        eax5 = reinterpret_cast<uint32_t>(GetCurrentThreadId(v2, esi3));
        eax6 = reinterpret_cast<uint32_t>(GetTickCount(v2, esi3));
        QueryPerformanceCounter();
        esi7 = reinterpret_cast<void**>(eax4 ^ eax5 ^ eax6 ^ (v8 ^ v9));
        if (!reinterpret_cast<int1_t>(esi7 == 0xbb40e64e)) {
            if (!(0xffff0000 & reinterpret_cast<unsigned char>(esi7))) {
                esi7 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi7) | (reinterpret_cast<unsigned char>(esi7) | 0x4711) << 16);
            }
        } else {
            esi7 = reinterpret_cast<void**>(0xbb40e64f);
        }
        g1000d050 = esi7;
        g1000d054 = reinterpret_cast<int32_t>(~reinterpret_cast<unsigned char>(esi7));
    } else {
        g1000d054 = reinterpret_cast<int32_t>(~reinterpret_cast<unsigned char>(eax1));
    }
    return;
}

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

int32_t g1000a194 = 0;

void fun_1000222e(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
    void** ebx8;
    struct s12* ebp9;
    int32_t ebp10;
    void** edx11;
    int1_t zf12;
    void** edx13;
    int32_t ebp14;
    int32_t eax15;
    int32_t eax16;
    int32_t ebp17;
    int32_t ebp18;
    uint32_t eax19;
    int32_t ebp20;
    void** eax21;
    int32_t ebp22;
    int32_t eax23;
    int32_t ebp24;
    uint32_t eax25;
    int32_t ebp26;
    int32_t ebp27;
    int32_t ebp28;
    int32_t eax29;
    int32_t eax30;
    int32_t ebp31;
    int32_t ebp32;

    fun_10004570(0x1000c350, 12, __return_address());
    ebx8 = ebp9->f8;
    *reinterpret_cast<void***>(ebp10 - 28) = reinterpret_cast<void**>(1);
    if (edx11 || (zf12 = g1000de20 == edx13, !zf12)) {
        *reinterpret_cast<uint32_t*>(ebp14 - 4) = 0;
        if (edx11 == 1 || reinterpret_cast<int1_t>(edx11 == 2)) {
            eax15 = g1000a194;
            if (eax15) {
                eax16 = reinterpret_cast<int32_t>(eax15(ebx8, edx11, ecx));
                *reinterpret_cast<int32_t*>(ebp17 - 28) = eax16;
            }
            if (!*reinterpret_cast<int32_t*>(ebp18 - 28)) 
                goto addr_10002315_6;
            eax19 = fun_100020ca(ecx, ebx8, edx11, ecx, 0x1000c350, 12, __return_address(), a2, a3, a4, a5, a6, a7);
            *reinterpret_cast<uint32_t*>(ebp20 - 28) = eax19;
            if (eax19) 
                goto addr_10002292_8;
        } else {
            addr_10002292_8:
            eax21 = fun_100048c9(ebx8, edx11, ecx);
            *reinterpret_cast<void***>(ebp22 - 28) = eax21;
            if (reinterpret_cast<int1_t>(edx11 == 1) && (!eax21 && (fun_100048c9(ebx8, eax21, ecx), fun_100020ca(ecx, ebx8, 0, ecx, 0x1000c350, 12, __return_address(), a2, a3, a4, a5, a6, a7), eax23 = g1000a194, !!eax23))) {
                eax23(ebx8, 0, ecx);
                goto addr_100022c6_10;
            }
        }
    } else {
        addr_1000231c_11:
        goto addr_1000231e_12;
    }
    addr_10002315_6:
    *reinterpret_cast<int32_t*>(ebp24 - 4) = -2;
    goto addr_1000231c_11;
    addr_100022c6_10:
    if (!edx11 || reinterpret_cast<int1_t>(edx11 == 3)) {
        eax25 = fun_100020ca(ecx, ebx8, edx11, ecx, 0x1000c350, 12, __return_address(), a2, a3, a4, a5, a6, a7);
        if (!eax25) {
            *reinterpret_cast<uint32_t*>(ebp26 - 28) = *reinterpret_cast<uint32_t*>(ebp27 - 28) & eax25;
        }
        if (*reinterpret_cast<int32_t*>(ebp28 - 28) && (eax29 = g1000a194, !!eax29)) {
            eax30 = reinterpret_cast<int32_t>(eax29(ebx8, edx11, ecx));
            *reinterpret_cast<int32_t*>(ebp31 - 28) = eax30;
        }
    }
    *reinterpret_cast<int32_t*>(ebp32 - 4) = -2;
    addr_1000231e_12:
    fun_100045b5(ecx, 0x1000c350, 12, __return_address(), a2, a3);
    goto 0x1000c350;
}

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

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

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

int32_t HeapAlloc = 0xcc10;

void** g1000ead8;

void** fun_10004bb8(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void** a16, void** a17, void** a18, void** a19, void** a20) {
    void** v21;
    void** v22;
    void** ebp23;
    void** v24;
    void** ebx25;
    void** ebx26;
    void** eax27;
    void** eax28;
    void** v29;
    void** esi30;
    void** v31;
    void** edi32;
    int1_t zf33;
    void** eax34;
    void** v35;
    void** eax36;
    int1_t zf37;
    int32_t eax38;
    void** eax39;
    void** eax40;

    v21 = reinterpret_cast<void**>(__return_address());
    v22 = ebp23;
    v24 = ebx25;
    ebx26 = a2;
    if (reinterpret_cast<unsigned char>(ebx26) > reinterpret_cast<unsigned char>(0xffffffe0)) {
        fun_10004c5b(ecx, ebx26, v24, v22, v21, a2, a3);
        eax27 = fun_10002896(ebx26, v24, v22, v21, a2, a3, a4, a5, a6, a7, a8);
        *reinterpret_cast<void***>(eax27) = reinterpret_cast<void**>(12);
        eax28 = reinterpret_cast<void**>(0);
    } else {
        v29 = esi30;
        v31 = edi32;
        do {
            zf33 = g1000e2e8 == 0;
            if (zf33) {
                fun_10007b81(ecx, v31, v29, v24, v22, v21, a2);
                fun_100079d2(ecx, 30, v31, v29, v24);
                fun_10003bf2(ecx, 0xff, 30, v31, v29, v24, v22);
                ecx = reinterpret_cast<void**>(30);
            }
            if (!ebx26) {
                eax34 = reinterpret_cast<void**>(1);
            } else {
                eax34 = ebx26;
            }
            v35 = g1000e2e8;
            eax36 = reinterpret_cast<void**>(HeapAlloc(ecx));
            if (eax36) 
                goto addr_10004c2f_10;
            zf37 = g1000ead8 == eax36;
            if (zf37) 
                goto addr_10004c21_12;
            eax38 = fun_10004c5b(ecx, ebx26, v35, 0, eax34, v31, v29);
            ecx = ebx26;
        } while (eax38);
        goto addr_10004c1f_14;
    }
    addr_10004c49_15:
    return eax28;
    addr_10004c2f_10:
    eax28 = eax36;
    goto addr_10004c49_15;
    addr_10004c21_12:
    eax39 = fun_10002896(ecx, v35, 0, eax34, v31, v29, v24, v22, v21, a2, a3);
    *reinterpret_cast<void***>(eax39) = reinterpret_cast<void**>(12);
    addr_10004c28_16:
    eax40 = fun_10002896(ecx, v35, 0, eax34, v31, v29, v24, v22, v21, a2, a3);
    *reinterpret_cast<void***>(eax40) = reinterpret_cast<void**>(12);
    goto addr_10004c2f_10;
    addr_10004c1f_14:
    goto addr_10004c28_16;
}

void fun_1000496a(void** ecx, void*** a2, int32_t a3) {
    *reinterpret_cast<void***>(ecx) = reinterpret_cast<void**>("2J");
    *reinterpret_cast<void***>(ecx + 4) = *a2;
    *reinterpret_cast<void***>(ecx + 8) = reinterpret_cast<void**>(0);
    return;
}

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

int32_t fun_10004ba1(void** ecx, void** a2, void** a3) {
    void** ebp4;
    int32_t eax5;
    uint32_t eax6;

    eax5 = fun_10004b65(ecx, a2, ebp4, __return_address(), a2, a3);
    eax6 = reinterpret_cast<uint32_t>(-eax5);
    return reinterpret_cast<int32_t>(-(eax6 - (eax6 + reinterpret_cast<uint1_t>(eax6 < eax6 + reinterpret_cast<uint1_t>(!!eax5))))) - 1;
}

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

void** fun_10004a59(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8) {
    void** esi9;
    void** ebp10;

    *reinterpret_cast<void***>(ecx + 4) = reinterpret_cast<void**>(0);
    *reinterpret_cast<void***>(ecx) = reinterpret_cast<void**>("2J");
    *reinterpret_cast<void***>(ecx + 8) = reinterpret_cast<void**>(0);
    fun_100049f2(ecx, a2, esi9, ebp10, __return_address(), a2, a3, a4, a5, a6, a7, a8);
    return ecx;
}

int32_t RaiseException = 0xcc1c;

void fun_10004c83(void** ecx, void* a2, unsigned char* a3) {
    void* ebp4;
    int32_t ecx5;
    int32_t v6;
    int32_t v7;
    int32_t v8;

    ebp4 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    ecx5 = 8;
    while (ecx5) {
        --ecx5;
    }
    if (a3 && *a3 & 8) {
    }
    RaiseException(v6, v7, v8, reinterpret_cast<int32_t>(ebp4) - 12);
    return;
}

void** fun_10002854(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
    void** eax7;
    uint32_t ecx8;
    void* eax9;

    eax7 = a2;
    ecx8 = 0;
    do {
        if (eax7 == *reinterpret_cast<void***>(ecx8 * 8 + 0x1000d060)) 
            break;
        ++ecx8;
    } while (ecx8 < 45);
    goto addr_1000286d_4;
    return *reinterpret_cast<void***>(ecx8 * 8 + 0x1000d064);
    addr_1000286d_4:
    if (reinterpret_cast<uint32_t>(eax7 + 0xffffffed) > 17) {
        eax9 = reinterpret_cast<void*>(eax7 + 0xffffff44);
        return (reinterpret_cast<uint32_t>(eax9) - (reinterpret_cast<uint32_t>(eax9) + reinterpret_cast<uint1_t>(reinterpret_cast<uint32_t>(eax9) < reinterpret_cast<uint32_t>(eax9) + reinterpret_cast<uint1_t>(14 < reinterpret_cast<uint32_t>(eax9)))) & 14) + 8;
    } else {
        return 13;
    }
}

uint32_t g1000fb24;

void fun_10004ccf(void** ecx) {
    g1000fb24 = 0;
    return;
}

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

struct s13 {
    signed char[32] pad32;
    void** f32;
    signed char[31] pad64;
    void** f64;
};

struct s13* fun_100056b6(void** ecx);

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

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

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

struct s14 {
    signed char[4] pad4;
    unsigned char f4;
};

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

uint32_t fun_10002556(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
    void** esi8;
    void** ebp9;
    void** eax10;
    void** eax11;
    void** ecx12;
    void** eax13;
    void** v14;
    struct s13* eax15;
    struct s13* eax16;
    void** ebx17;
    uint32_t eax18;
    uint32_t eax19;
    void** eax20;
    int1_t zf21;
    void** edi22;
    void** edi23;
    void** eax24;
    void** eax25;
    void** edi26;
    void** ecx27;
    struct s14* eax28;
    uint32_t edx29;
    uint32_t eax30;
    void** eax31;

    eax10 = fun_1000586b(ecx, a3, esi8, ecx, ebp9, __return_address(), a2, a3, a4);
    eax11 = *reinterpret_cast<void***>(a3 + 12);
    ecx12 = a3;
    if (*reinterpret_cast<unsigned char*>(&eax11) & 0x82) {
        if (!(*reinterpret_cast<unsigned char*>(&eax11) & 64)) {
            if (!(*reinterpret_cast<unsigned char*>(&eax11) & 1)) {
                addr_100025b6_4:
                eax13 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a3 + 12)) & 0xffffffef | 2);
                *reinterpret_cast<void***>(a3 + 12) = eax13;
                *reinterpret_cast<void***>(a3 + 4) = reinterpret_cast<void**>(0);
                v14 = reinterpret_cast<void**>(0);
                if (!(reinterpret_cast<unsigned char>(eax13) & 0x10c) && ((eax15 = fun_100056b6(ecx12), a3 != &eax15->f32) && (eax16 = fun_100056b6(ecx12), !reinterpret_cast<int1_t>(a3 == &eax16->f64)) || (eax18 = fun_10005660(ecx12, eax10, ebx17, esi8, 0, ebp9, __return_address(), a2, eax10), ecx12 = eax10, !eax18))) {
                    fun_10005617(ecx12, a3, ebx17, esi8, 0, ebp9, __return_address(), a2, eax10, a4, a5, a6);
                    ecx12 = a3;
                }
            } else {
                *reinterpret_cast<void***>(a3 + 4) = reinterpret_cast<void**>(0);
                if (!(*reinterpret_cast<unsigned char*>(&eax11) & 16)) {
                    *reinterpret_cast<void***>(a3 + 12) = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax11) | 32);
                    eax19 = 0xffffffff;
                    goto addr_100026b6_8;
                } else {
                    ecx12 = *reinterpret_cast<void***>(a3 + 8);
                    *reinterpret_cast<void***>(a3) = ecx12;
                    *reinterpret_cast<void***>(a3 + 12) = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax11) & 0xfffffffe);
                    goto addr_100025b6_4;
                }
            }
        } else {
            eax20 = fun_10002896(ecx12, esi8, ecx, ebp9, __return_address(), a2, eax10, a4, a5, a6, a7);
            *reinterpret_cast<void***>(eax20) = reinterpret_cast<void**>(34);
            goto addr_1000257c_11;
        }
    } else {
        eax20 = fun_10002896(ecx12, esi8, ecx, ebp9, __return_address(), a2, eax10, a4, a5, a6, a7);
        *reinterpret_cast<void***>(eax20) = reinterpret_cast<void**>(9);
        goto addr_1000257c_11;
    }
    zf21 = (reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a3 + 12)) & 0x108) == 0;
    if (zf21) {
        edi22 = reinterpret_cast<void**>(1);
        eax24 = fun_10005543(ecx12, eax10, reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 + 8, 1, edi23, ebx17, esi8, 0);
        v14 = eax24;
    } else {
        eax25 = *reinterpret_cast<void***>(a3 + 8);
        edi26 = *reinterpret_cast<void***>(a3);
        *reinterpret_cast<void***>(a3) = eax25 + 1;
        edi22 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edi26) - reinterpret_cast<unsigned char>(eax25));
        ecx27 = *reinterpret_cast<void***>(a3 + 24) - 1;
        *reinterpret_cast<void***>(a3 + 4) = ecx27;
        if (reinterpret_cast<signed char>(edi22) <= reinterpret_cast<signed char>(0)) {
            if (eax10 == 0xffffffff || eax10 == 0xfffffffe) {
                eax28 = reinterpret_cast<struct s14*>(0x1000d950);
            } else {
                edx29 = reinterpret_cast<uint32_t>(reinterpret_cast<signed char>(eax10) >> 5);
                eax28 = reinterpret_cast<struct s14*>(((reinterpret_cast<unsigned char>(eax10) & 31) << 6) + reinterpret_cast<int32_t>(*reinterpret_cast<void**>(edx29 * 4 + 0x1000fb40)));
            }
            if (!(eax28->f4 & 32)) 
                goto addr_1000267f_20;
            eax30 = fun_10004d5c(eax10, eax10, 0, 0, 2, edi23, ebx17, esi8);
            if ((eax30 & edx29) == 0xffffffff) 
                goto addr_100026a4_22;
        } else {
            eax31 = fun_10005543(ecx27, eax10, eax25, edi22, edi23, ebx17, esi8, 0);
            v14 = eax31;
        }
        addr_1000267f_20:
        *reinterpret_cast<void***>(*reinterpret_cast<void***>(a3 + 8)) = a2;
    }
    if (v14 == edi22) {
        eax19 = reinterpret_cast<unsigned char>(a2) & 0xff;
    } else {
        addr_100026a4_22:
        *reinterpret_cast<void***>(a3 + 12) = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a3 + 12)) | 32);
        eax19 = 0xffffffff;
    }
    addr_100026b6_8:
    addr_100026b7_27:
    return eax19;
    addr_1000257c_11:
    *reinterpret_cast<void***>(a3 + 12) = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a3 + 12)) | 32);
    eax19 = 0xffffffff;
    goto addr_100026b7_27;
}

struct s13* fun_100056b6(void** ecx) {
    return 0x1000d990;
}

void** g1000fb2c;

uint32_t fun_10005660(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9) {
    int1_t cf10;
    void** ebp11;
    void** eax12;
    void** eax13;

    if (!reinterpret_cast<int1_t>(a2 == 0xfffffffe)) {
        if (reinterpret_cast<signed char>(a2) < reinterpret_cast<signed char>(0) || (cf10 = reinterpret_cast<unsigned char>(a2) < reinterpret_cast<unsigned char>(g1000fb2c), !cf10)) {
            eax12 = fun_10002896(ecx, ebp11, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
            *reinterpret_cast<void***>(eax12) = reinterpret_cast<void**>(9);
            fun_10002844(ecx);
        } else {
            return reinterpret_cast<uint32_t>(static_cast<int32_t>(*reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>((reinterpret_cast<signed char>(a2) >> 5) * 4 + 0x1000fb40)) + ((reinterpret_cast<unsigned char>(a2) & 31) << 6) + 4))) & 64;
        }
    } else {
        eax13 = fun_10002896(ecx, ebp11, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
        *reinterpret_cast<void***>(eax13) = reinterpret_cast<void**>(9);
    }
    return 0;
}

int32_t g1000e2f0;

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

void fun_10005617(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12) {
    void** ebp13;
    void** eax14;
    void** eax15;

    ++g1000e2f0;
    eax14 = fun_10003ae8(ecx, 0x1000, ebp13, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
    *reinterpret_cast<void***>(a2 + 8) = eax14;
    if (!eax14) {
        *reinterpret_cast<void***>(a2 + 12) = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a2 + 12)) | 4);
        *reinterpret_cast<void***>(a2 + 8) = a2 + 20;
        *reinterpret_cast<void***>(a2 + 24) = reinterpret_cast<void**>(2);
    } else {
        *reinterpret_cast<void***>(a2 + 12) = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a2 + 12)) | 8);
        *reinterpret_cast<void***>(a2 + 24) = reinterpret_cast<void**>(0x1000);
    }
    eax15 = *reinterpret_cast<void***>(a2 + 8);
    *reinterpret_cast<void***>(a2 + 4) = reinterpret_cast<void**>(0);
    *reinterpret_cast<void***>(a2) = eax15;
    return;
}

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

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

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

struct s16 {
    signed char[16] pad16;
    void** f16;
};

struct s17 {
    signed char[12] pad12;
    void** f12;
};

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

void fun_1000560f(void** ecx);

void** fun_10005543(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8) {
    void** ebx9;
    struct s15* ebp10;
    int1_t cf11;
    void** edi12;
    uint32_t esi13;
    void** eax14;
    void** eax15;
    int32_t ebp16;
    void** eax17;
    void** eax18;
    int32_t ebp19;
    void** v20;
    struct s16* ebp21;
    void** v22;
    struct s17* ebp23;
    void** eax24;
    int32_t ebp25;
    int32_t ebp26;
    void** eax27;
    void** eax28;

    fun_10004570(0x1000c4f0, 16, __return_address());
    ebx9 = ebp10->f8;
    if (!reinterpret_cast<int1_t>(ebx9 == 0xfffffffe)) {
        if (reinterpret_cast<signed char>(ebx9) < reinterpret_cast<signed char>(0) || ((cf11 = reinterpret_cast<unsigned char>(ebx9) < reinterpret_cast<unsigned char>(g1000fb2c), !cf11) || (edi12 = reinterpret_cast<void**>((reinterpret_cast<signed char>(ebx9) >> 5) * 4 + 0x1000fb40), esi13 = (reinterpret_cast<unsigned char>(ebx9) & 31) << 6, (reinterpret_cast<uint32_t>(static_cast<int32_t>(*reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(*edi12) + esi13 + 4))) & 1) == 0))) {
            eax14 = fun_100028a9(ecx, 0x1000c4f0, 16, __return_address(), a2, a3, a4, a5, a6, a7);
            *reinterpret_cast<void***>(eax14) = reinterpret_cast<void**>(0);
            eax15 = fun_10002896(ecx, 0x1000c4f0, 16, __return_address(), a2, a3, a4, a5, a6, a7, a8);
            *reinterpret_cast<void***>(eax15) = reinterpret_cast<void**>(9);
            fun_10002844(ecx);
        } else {
            fun_10007d47(ecx, ebx9, 0x1000c4f0, 16, __return_address(), a2, a3);
            ecx = ebx9;
            *reinterpret_cast<uint32_t*>(ebp16 - 4) = 0;
            if (!(*reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(*edi12) + esi13 + 4) & 1)) {
                eax17 = fun_10002896(ecx, 0x1000c4f0, 16, __return_address(), a2, a3, a4, a5, a6, a7, a8);
                *reinterpret_cast<void***>(eax17) = reinterpret_cast<void**>(9);
                eax18 = fun_100028a9(ecx, 0x1000c4f0, 16, __return_address(), a2, a3, a4, a5, a6, a7);
                *reinterpret_cast<void***>(eax18) = reinterpret_cast<void**>(0);
                *reinterpret_cast<uint32_t*>(ebp19 - 28) = 0xffffffff;
            } else {
                v20 = ebp21->f16;
                v22 = ebp23->f12;
                eax24 = fun_10004e46(ecx, ebx9, v22, v20, 0x1000c4f0, 16, __return_address());
                *reinterpret_cast<void***>(ebp25 - 28) = eax24;
            }
            *reinterpret_cast<int32_t*>(ebp26 - 4) = -2;
            fun_1000560f(ecx);
            goto addr_10005606_8;
        }
    } else {
        eax27 = fun_100028a9(ecx, 0x1000c4f0, 16, __return_address(), a2, a3, a4, a5, a6, a7);
        *reinterpret_cast<void***>(eax27) = reinterpret_cast<void**>(0);
        eax28 = fun_10002896(ecx, 0x1000c4f0, 16, __return_address(), a2, a3, a4, a5, a6, a7, a8);
        *reinterpret_cast<void***>(eax28) = reinterpret_cast<void**>(9);
    }
    addr_10005606_8:
    fun_100045b5(ecx, 0x1000c4f0, 16, __return_address(), a2, a3);
    goto 0x1000c4f0;
}

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

struct s19 {
    signed char[20] pad20;
    void** f20;
};

struct s20 {
    signed char[16] pad16;
    void** f16;
};

struct s21 {
    signed char[12] pad12;
    void** f12;
};

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

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

void fun_10004e3c(void** ecx);

uint32_t fun_10004d5c(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8) {
    int32_t ebp9;
    int32_t ebp10;
    struct s18* ebp11;
    int1_t cf12;
    void** edi13;
    uint32_t esi14;
    void** eax15;
    void** eax16;
    void** v17;
    int32_t ebp18;
    void** eax19;
    void** eax20;
    int32_t ebp21;
    int32_t ebp22;
    void** v23;
    struct s19* ebp24;
    void** v25;
    struct s20* ebp26;
    void** v27;
    struct s21* ebp28;
    void** v29;
    struct s22* ebp30;
    void** eax31;
    int32_t ebp32;
    int32_t ebp33;
    int32_t edx34;
    int32_t ebp35;
    void** eax36;
    void** eax37;

    fun_10004570(0x1000c4d0, 20, __return_address());
    *reinterpret_cast<int32_t*>(ebp9 - 36) = -1;
    *reinterpret_cast<int32_t*>(ebp10 - 32) = -1;
    if (!reinterpret_cast<int1_t>(ebp11->f8 == 0xfffffffe)) {
        if (reinterpret_cast<signed char>(ebp11->f8) < reinterpret_cast<signed char>(0) || ((cf12 = reinterpret_cast<unsigned char>(ebp11->f8) < reinterpret_cast<unsigned char>(g1000fb2c), !cf12) || (edi13 = reinterpret_cast<void**>((reinterpret_cast<signed char>(ebp11->f8) >> 5) * 4 + 0x1000fb40), esi14 = (reinterpret_cast<unsigned char>(ebp11->f8) & 31) << 6, ecx = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(static_cast<int32_t>(*reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(*edi13) + esi14 + 4))) & 1), ecx == 0))) {
            eax15 = fun_100028a9(ecx, 0x1000c4d0, 20, __return_address(), a2, a3, a4, a5, a6, a7);
            *reinterpret_cast<void***>(eax15) = reinterpret_cast<void**>(0);
            eax16 = fun_10002896(ecx, 0x1000c4d0, 20, __return_address(), a2, a3, a4, a5, a6, a7, a8);
            *reinterpret_cast<void***>(eax16) = reinterpret_cast<void**>(9);
            fun_10002844(ecx);
        } else {
            v17 = ebp11->f8;
            fun_10007d47(ecx, v17, 0x1000c4d0, 20, __return_address(), a2, a3);
            ecx = v17;
            *reinterpret_cast<uint32_t*>(ebp18 - 4) = 0;
            if (!(*reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(*edi13) + esi14 + 4) & 1)) {
                eax19 = fun_10002896(ecx, 0x1000c4d0, 20, __return_address(), a2, a3, a4, a5, a6, a7, a8);
                *reinterpret_cast<void***>(eax19) = reinterpret_cast<void**>(9);
                eax20 = fun_100028a9(ecx, 0x1000c4d0, 20, __return_address(), a2, a3, a4, a5, a6, a7);
                *reinterpret_cast<void***>(eax20) = reinterpret_cast<void**>(0);
                *reinterpret_cast<int32_t*>(ebp21 - 36) = -1;
                *reinterpret_cast<int32_t*>(ebp22 - 32) = -1;
            } else {
                v23 = ebp24->f20;
                v25 = ebp26->f16;
                v27 = ebp28->f12;
                v29 = ebp30->f8;
                eax31 = fun_10004cd7(ecx, v29, v27, v25, v23);
                *reinterpret_cast<void***>(ebp32 - 36) = eax31;
                *reinterpret_cast<int32_t*>(ebp33 - 32) = edx34;
            }
            *reinterpret_cast<int32_t*>(ebp35 - 4) = -2;
            fun_10004e3c(ecx);
            goto addr_10004e36_8;
        }
    } else {
        eax36 = fun_100028a9(ecx, 0x1000c4d0, 20, __return_address(), a2, a3, a4, a5, a6, a7);
        *reinterpret_cast<void***>(eax36) = reinterpret_cast<void**>(0);
        eax37 = fun_10002896(ecx, 0x1000c4d0, 20, __return_address(), a2, a3, a4, a5, a6, a7, a8);
        *reinterpret_cast<void***>(eax37) = reinterpret_cast<void**>(9);
    }
    addr_10004e36_8:
    fun_100045b5(ecx, 0x1000c4d0, 20, __return_address(), a2, a3);
    goto 0x1000c4d0;
}

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

int32_t GetCPInfo = 0xc9f4;

struct s24 {
    signed char[12] pad12;
    void** f12;
};

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

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

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

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

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

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

struct s29 {
    signed char[12] pad12;
    void** f12;
};

void** fun_10002b81() {
    void* ebp1;
    void** eax2;
    uint32_t v3;
    void** v4;
    void** ebx5;
    void** v6;
    void** edi7;
    void** v8;
    void** v9;
    struct s23* esi10;
    int32_t eax11;
    void* ecx12;
    int32_t v13;
    int32_t esi14;
    signed char* eax15;
    void* esi16;
    uint32_t edx17;
    void* esi18;
    void* esi19;
    uint32_t edx20;
    void* esi21;
    void* esi22;
    void* eax23;
    unsigned char al24;
    unsigned char v25;
    void** ecx26;
    void** eax27;
    void** v28;
    struct s24* esi29;
    void** v30;
    struct s25* esi31;
    void** v32;
    void** v33;
    void** v34;
    struct s26* esi35;
    void** v36;
    struct s27* esi37;
    void** v38;
    struct s28* esi39;
    void** v40;
    struct s29* esi41;
    void** v42;
    void** v43;
    void** v44;
    void** v45;
    void* eax46;
    uint32_t ecx47;
    void* esi48;
    void* esi49;
    void* esi50;
    signed char cl51;
    void* esi52;
    void* esi53;
    void* esi54;
    void** ecx55;
    void** eax56;
    unsigned char v57;
    void** v58;
    void** v59;
    void** v60;
    void** v61;
    unsigned char v62;

    ebp1 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    eax2 = g1000d050;
    v3 = reinterpret_cast<unsigned char>(eax2) ^ reinterpret_cast<uint32_t>(ebp1);
    v4 = ebx5;
    v6 = edi7;
    v8 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp1) + 0xfffffae8);
    v9 = esi10->f4;
    eax11 = reinterpret_cast<int32_t>(GetCPInfo());
    if (!eax11) {
        ecx12 = reinterpret_cast<void*>(0);
        v13 = -97 - (esi14 + 0x11d);
        do {
            eax15 = reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(esi16) + reinterpret_cast<uint32_t>(ecx12) + 0x11d);
            edx17 = v13 + reinterpret_cast<uint32_t>(eax15);
            if (edx17 + 32 > 25) {
                if (edx17 > 25) {
                    *eax15 = 0;
                    continue;
                } else {
                    *reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(esi18) + reinterpret_cast<uint32_t>(ecx12) + 29) = reinterpret_cast<unsigned char>(*reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(esi19) + reinterpret_cast<uint32_t>(ecx12) + 29) | 32);
                    edx20 = reinterpret_cast<uint32_t>(ecx12) - 32;
                }
            } else {
                *reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(esi21) + reinterpret_cast<uint32_t>(ecx12) + 29) = reinterpret_cast<unsigned char>(*reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(esi22) + reinterpret_cast<uint32_t>(ecx12) + 29) | 16);
                edx20 = reinterpret_cast<uint32_t>(ecx12) + 32;
            }
            *eax15 = *reinterpret_cast<signed char*>(&edx20);
            ecx12 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ecx12) + 1);
        } while (reinterpret_cast<uint32_t>(ecx12) < 0x100);
    } else {
        eax23 = reinterpret_cast<void*>(0);
        do {
            *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(ebp1) + reinterpret_cast<uint32_t>(eax23) - 0x104) = *reinterpret_cast<signed char*>(&eax23);
            eax23 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(eax23) + 1);
        } while (reinterpret_cast<uint32_t>(eax23) < 0x100);
        al24 = v25;
        if (!al24) 
            goto addr_10002c04_13; else 
            goto addr_10002bd4_14;
    }
    addr_10002d03_15:
    ecx26 = reinterpret_cast<void**>(v3 ^ reinterpret_cast<uint32_t>(ebp1));
    eax27 = fun_10001cc4(ecx26, v6, ecx26, v6);
    return eax27;
    addr_10002c04_13:
    v28 = esi29->f12;
    v30 = esi31->f4;
    v32 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp1) + 0xfffffafc);
    v33 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp1) + 0xfffffefc);
    fun_10006c37(0, 1, v33, 0x100, v32, v30, v28, 0);
    v34 = esi35->f4;
    v36 = esi37->f12;
    fun_10006b0a(0, v36, 0x100, reinterpret_cast<uint32_t>(ebp1) + 0xfffffefc, 0x100, reinterpret_cast<uint32_t>(ebp1) + 0xfffffdfc, 0x100, v34, 0, 0, 1, v33, 0x100, v32, v30, v28, 0);
    v38 = esi39->f4;
    v40 = esi41->f12;
    fun_10006b0a(0, v40, 0x200, reinterpret_cast<uint32_t>(ebp1) + 0xfffffefc, 0x100, reinterpret_cast<uint32_t>(ebp1) + 0xfffffcfc, 0x100, v38, 0, v9, v8, v6, v4, v42, v43, v44, v45);
    eax46 = reinterpret_cast<void*>(0);
    do {
        ecx47 = *reinterpret_cast<uint16_t*>(reinterpret_cast<uint32_t>(ebp1) + reinterpret_cast<uint32_t>(eax46) * 2 - 0x504);
        if (!(*reinterpret_cast<unsigned char*>(&ecx47) & 1)) {
            if (!(*reinterpret_cast<unsigned char*>(&ecx47) & 2)) {
                *reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(esi48) + reinterpret_cast<uint32_t>(eax46) + 0x11d) = 0;
                continue;
            } else {
                *reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(esi49) + reinterpret_cast<uint32_t>(eax46) + 29) = reinterpret_cast<unsigned char>(*reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(esi50) + reinterpret_cast<uint32_t>(eax46) + 29) | 32);
                cl51 = *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(ebp1) + reinterpret_cast<uint32_t>(eax46) - 0x304);
            }
        } else {
            *reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(esi52) + reinterpret_cast<uint32_t>(eax46) + 29) = reinterpret_cast<unsigned char>(*reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(esi53) + reinterpret_cast<uint32_t>(eax46) + 29) | 16);
            cl51 = *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(ebp1) + reinterpret_cast<uint32_t>(eax46) - 0x204);
        }
        *reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(esi54) + reinterpret_cast<uint32_t>(eax46) + 0x11d) = cl51;
        eax46 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(eax46) + 1);
    } while (reinterpret_cast<uint32_t>(eax46) < 0x100);
    goto addr_10002d03_15;
    addr_10002bd4_14:
    do {
        ecx55 = reinterpret_cast<void**>(static_cast<uint32_t>(al24));
        eax56 = reinterpret_cast<void**>(static_cast<uint32_t>(v57));
        if (reinterpret_cast<unsigned char>(ecx55) <= reinterpret_cast<unsigned char>(eax56)) {
            fun_10005bc0(ecx55, reinterpret_cast<uint32_t>(ebp1) + reinterpret_cast<unsigned char>(ecx55) + 0xfffffefc, 32, reinterpret_cast<unsigned char>(eax56) - reinterpret_cast<unsigned char>(ecx55) + 1, v9, v8, v6, v4, v58, v59, v60, v61);
        }
        al24 = v62;
    } while (al24);
    goto addr_10002c04_13;
}

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

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

struct s30 {
    signed char[112] pad112;
    uint32_t f112;
};

void** fun_10006c37(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8) {
    void*** ebp9;
    void** ecx10;
    void** v11;
    void** v12;
    void** v13;
    void** v14;
    void** ebp15;
    void** eax16;
    signed char v17;
    struct s30* v18;

    ebp9 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    ecx10 = reinterpret_cast<void**>(ebp9 + 0xfffffff0);
    fun_10001d91(ecx10, a1, v11, v12, v13, v14, ebp15, __return_address(), a1, a2, a3);
    eax16 = fun_10006b50(ecx10, ebp9 + 0xfffffff0, a2, a3, a4, a5, a6, a8);
    if (v17) {
        v18->f112 = v18->f112 & 0xfffffffd;
    }
    return eax16;
}

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

struct s31 {
    signed char[112] pad112;
    uint32_t f112;
};

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

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

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

int32_t GetStartupInfoW = 0xcb26;

void** g1000fb40;

struct s32 {
    signed char[3] pad3;
    void** f3;
    signed char[27] pad31;
    unsigned char f31;
    int16_t f32;
    signed char f33;
    signed char[12] pad47;
    void** f47;
    signed char[3] pad51;
    void** f51;
};

int32_t GetFileType = 0xcb18;

struct s33 {
    int32_t f0;
    void** f4;
    signed char[3] pad8;
    int32_t f8;
};

int32_t InitializeCriticalSectionAndSpinCount = 0xcaf0;

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

int32_t GetStdHandle = 0xcae0;

int32_t SetHandleCount = 0xcace;

void fun_10003e6f(void** ecx, void** a2) {
    void** ebp3;
    void** v4;
    void** v5;
    void** v6;
    void** edi7;
    void** edi8;
    void** v9;
    void** esi10;
    void** v11;
    void** v12;
    void** v13;
    void** v14;
    void** v15;
    void** v16;
    void** v17;
    void** eax18;
    void** ecx19;
    struct s32* eax20;
    void** esi21;
    void** v22;
    void** ebx23;
    void** v24;
    int16_t v25;
    void** v26;
    void** ebx27;
    void** eax28;
    void** v29;
    int32_t* v30;
    int1_t less31;
    void** edi32;
    int32_t ebx33;
    int32_t v34;
    int32_t eax35;
    struct s33* esi36;
    uint32_t eax37;
    struct s34* tmp32_38;
    void** eax39;
    uint32_t eax40;
    uint32_t eax41;
    void*** edi42;
    void** v43;
    void** v44;
    void** v45;
    void** v46;
    void** eax47;
    void** tmp32_48;
    struct s32* eax49;
    int1_t less50;

    fun_10007b81(ecx, ebp3, __return_address(), a2, v4, v5, v6);
    fun_100079d2(ecx, a2, ebp3, __return_address(), a2);
    fun_10003e4a(a2, 0xff, ebp3, __return_address(), a2);
    edi7 = edi8;
    v9 = esi10;
    v11 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 - 4 + 4 - 4 - 4 + 4 + 4 - 4 - 4 + 4 - 4 + 0xffffffb4);
    GetStartupInfoW(a2);
    eax18 = fun_10003b2d(a2, 32, 64, v11, v9, v12, v13, v14, v15, v16, v17);
    ecx19 = reinterpret_cast<void**>(0);
    if (eax18) {
        g1000fb40 = eax18;
        g1000fb2c = reinterpret_cast<void**>(32);
        if (reinterpret_cast<unsigned char>(eax18) < reinterpret_cast<unsigned char>(eax18 + 0x800)) {
            eax20 = reinterpret_cast<struct s32*>(eax18 + 5);
            do {
                *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(eax20) + 0xfffffffb) = reinterpret_cast<void**>(0xffffffff);
                *reinterpret_cast<int16_t*>(reinterpret_cast<uint32_t>(eax20) + 0xffffffff) = 0xa00;
                eax20->f3 = reinterpret_cast<void**>(0);
                eax20->f31 = reinterpret_cast<unsigned char>(0xa00);
                *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(eax20) + 33) = 10;
                eax20->f51 = reinterpret_cast<void**>(0);
                eax20->f47 = reinterpret_cast<void**>(0);
                esi21 = g1000fb40;
                eax20 = reinterpret_cast<struct s32*>(reinterpret_cast<uint32_t>(eax20) + 64);
            } while (reinterpret_cast<unsigned char>(reinterpret_cast<uint32_t>(eax20) + 0xfffffffb) < reinterpret_cast<unsigned char>(esi21 + 0x800));
        }
        v22 = ebx23;
        v24 = edi7;
        if (!v25) 
            goto addr_10004020_7;
        if (!v26) 
            goto addr_10004020_7;
        ebx27 = *reinterpret_cast<void***>(v26);
        eax28 = v26 + 4;
        v29 = eax28;
        v30 = reinterpret_cast<int32_t*>(reinterpret_cast<unsigned char>(eax28) + reinterpret_cast<unsigned char>(ebx27));
        if (reinterpret_cast<signed char>(ebx27) >= reinterpret_cast<signed char>(0x800)) {
            ebx27 = reinterpret_cast<void**>(0x800);
        }
        less31 = reinterpret_cast<signed char>(g1000fb2c) < reinterpret_cast<signed char>(ebx27);
        if (less31) 
            goto addr_10003f3d_12;
    } else {
        goto addr_100040ca_14;
    }
    addr_10003fa8_15:
    edi32 = reinterpret_cast<void**>(0);
    if (reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(ebx27) < reinterpret_cast<signed char>(0)) | reinterpret_cast<uint1_t>(ebx27 == 0)) {
        addr_10004020_7:
        ebx33 = 0;
    } else {
        do {
            if (*v30 != -1 && (*v30 != -2 && ((ecx19 = v29, ecx19 = *reinterpret_cast<void***>(ecx19), !!(reinterpret_cast<unsigned char>(ecx19) & 1)) && (reinterpret_cast<unsigned char>(ecx19) & 8 || (v34 = *v30, eax35 = reinterpret_cast<int32_t>(GetFileType(v34)), !!eax35))))) {
                esi36 = reinterpret_cast<struct s33*>(((reinterpret_cast<unsigned char>(edi32) & 31) << 6) + reinterpret_cast<int32_t>(*reinterpret_cast<int32_t**>((reinterpret_cast<signed char>(edi32) >> 5) * 4 + 0x1000fb40)));
                esi36->f0 = *v30;
                esi36->f4 = *reinterpret_cast<void***>(v29);
                eax37 = reinterpret_cast<uint32_t>(InitializeCriticalSectionAndSpinCount(esi36 + 1));
                if (!eax37) 
                    goto addr_100040cd_18;
                esi36->f8 = esi36->f8 + 1;
            }
            ++v30;
            ++edi32;
            ++v29;
        } while (reinterpret_cast<signed char>(edi32) < reinterpret_cast<signed char>(ebx27));
        goto addr_10004020_7;
    }
    do {
        tmp32_38 = reinterpret_cast<struct s34*>((ebx33 << 6) + reinterpret_cast<unsigned char>(g1000fb40));
        if (tmp32_38->f0 == 0xffffffff || tmp32_38->f0 == 0xfffffffe) {
            tmp32_38->f4 = 0x81;
            if (ebx33) {
            }
            eax39 = reinterpret_cast<void**>(GetStdHandle(ecx19));
            if (eax39 == 0xffffffff || (!eax39 || (eax40 = reinterpret_cast<uint32_t>(GetFileType(ecx19, eax39)), eax40 == 0))) {
                tmp32_38->f4 = reinterpret_cast<unsigned char>(tmp32_38->f4 | 64);
                tmp32_38->f0 = reinterpret_cast<void**>(0xfffffffe);
            } else {
                eax41 = eax40 & 0xff;
                tmp32_38->f0 = eax39;
                if (eax41 != 2) {
                    if (eax41 == 3) {
                        tmp32_38->f4 = reinterpret_cast<unsigned char>(tmp32_38->f4 | 8);
                    }
                } else {
                    tmp32_38->f4 = reinterpret_cast<unsigned char>(tmp32_38->f4 | 64);
                }
                eax37 = reinterpret_cast<uint32_t>(InitializeCriticalSectionAndSpinCount(ecx19, tmp32_38 + 1, 0xfa0, eax39));
                if (!eax37) 
                    goto addr_100040cd_18;
                tmp32_38->f8 = tmp32_38->f8 + 1;
            }
        } else {
            tmp32_38->f4 = reinterpret_cast<unsigned char>(tmp32_38->f4 | 0x80);
        }
        ++ebx33;
    } while (ebx33 < 3);
    SetHandleCount(ecx19);
    addr_100040c8_36:
    addr_100040ca_14:
    goto 0xff;
    addr_100040cd_18:
    goto addr_100040c8_36;
    addr_10003f3d_12:
    edi42 = reinterpret_cast<void***>(0x1000fb44);
    do {
        eax47 = fun_10003b2d(ecx19, 32, 64, v24, v22, v11, v9, v43, v44, v45, v46);
        ecx19 = reinterpret_cast<void**>(64);
        if (!eax47) 
            break;
        tmp32_48 = g1000fb2c + 32;
        g1000fb2c = tmp32_48;
        ecx19 = eax47 + 0x800;
        *edi42 = eax47;
        if (reinterpret_cast<unsigned char>(eax47) < reinterpret_cast<unsigned char>(ecx19)) {
            eax49 = reinterpret_cast<struct s32*>(eax47 + 5);
            do {
                *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(eax49) + 0xfffffffb) = reinterpret_cast<void**>(0xffffffff);
                eax49->f3 = reinterpret_cast<void**>(0);
                eax49->f31 = reinterpret_cast<unsigned char>(eax49->f31 & 0x80);
                eax49->f51 = reinterpret_cast<void**>(0);
                *reinterpret_cast<int16_t*>(reinterpret_cast<uint32_t>(eax49) + 0xffffffff) = 0xa00;
                eax49->f32 = 0xa0a;
                eax49->f47 = reinterpret_cast<void**>(0);
                eax49 = reinterpret_cast<struct s32*>(reinterpret_cast<uint32_t>(eax49) + 64);
                ecx19 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*edi42) + reinterpret_cast<unsigned char>(0x800));
            } while (reinterpret_cast<unsigned char>(reinterpret_cast<uint32_t>(eax49) + 0xfffffffb) < reinterpret_cast<unsigned char>(ecx19));
        }
        edi42 = edi42 + 4;
        less50 = reinterpret_cast<signed char>(g1000fb2c) < reinterpret_cast<signed char>(ebx27);
    } while (less50);
    goto addr_10003fa0_42;
    ebx27 = g1000fb2c;
    goto addr_10003fa8_15;
    addr_10003fa0_42:
    goto addr_10003fa8_15;
}

void** fun_10002416(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void** a16, void** a17, void** a18, void** a19) {
    void** v20;
    void** eax21;
    void** esi22;
    void** ebp23;
    void** eax24;
    void** eax25;

    if (a2 && (v20 = g1000e2e8, eax21 = reinterpret_cast<void**>(HeapFree(ecx, v20, 0, a2)), !eax21)) {
        eax24 = fun_10002896(ecx, esi22, v20, 0, a2, ebp23, __return_address(), a2, a3, a4, a5);
        eax25 = reinterpret_cast<void**>(GetLastError(ecx));
        eax21 = fun_10002854(ecx, eax25, esi22, v20, 0, a2);
        *reinterpret_cast<void***>(eax24) = eax21;
    }
    return eax21;
}

struct s35 {
    signed char[4] pad4;
    int32_t f4;
    int32_t f8;
    int32_t f12;
    int32_t f16;
    signed char[8] pad28;
    void** f28;
};

struct s36 {
    int32_t f0;
    int32_t f4;
};

struct s37 {
    int32_t f0;
    int32_t f4;
};

struct s38 {
    signed char[28] pad28;
    signed char f28;
    signed char[256] pad285;
    signed char f285;
};

void fun_10002b1d(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
    struct s35* eax7;
    void** edi8;
    void** esi9;
    struct s36* edi10;
    struct s37* edi11;
    struct s38* esi12;
    signed char* eax13;
    void* ecx14;
    int32_t edi15;
    signed char* eax16;
    int32_t esi17;

    fun_10005bc0(ecx, &eax7->f28, 0, 0x101, edi8, esi9, __return_address(), a2, a3, a4, a5, a6);
    eax7->f4 = 0;
    eax7->f8 = 0;
    eax7->f12 = 0;
    edi10 = reinterpret_cast<struct s36*>(&eax7->f16);
    edi10->f0 = 0;
    edi11 = reinterpret_cast<struct s37*>(&edi10->f4);
    edi11->f0 = 0;
    edi11->f4 = 0;
    esi12 = reinterpret_cast<struct s38*>(&eax7->f4 + 1 + 1);
    eax13 = &esi12->f28;
    ecx14 = reinterpret_cast<void*>(0x1000d1d0 - reinterpret_cast<int32_t>(esi12));
    edi15 = 0x101;
    do {
        *eax13 = *reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(ecx14) + reinterpret_cast<int32_t>(eax13));
        ++eax13;
        --edi15;
    } while (edi15);
    eax16 = &esi12->f285;
    esi17 = 0x100;
    do {
        *eax16 = *reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(eax16) + reinterpret_cast<int32_t>(ecx14));
        ++eax16;
        --esi17;
    } while (esi17);
    return;
}

void** fun_10002aee(void** a1, void** a2, void** a3) {
    int32_t eax4;
    int32_t eax5;
    int32_t eax6;
    int32_t eax7;

    eax4 = eax5 - 0x3a4;
    if (!eax4) {
        return 0x411;
    } else {
        eax6 = eax4 - 4;
        if (!eax6) {
            return 0x804;
        } else {
            eax7 = eax6 - 13;
            if (!eax7) {
                return 0x412;
            } else {
                if (!(eax7 - 1)) {
                    return 0x404;
                } else {
                    return 0;
                }
            }
        }
    }
}

void** fun_10003ae8(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15) {
    void** v16;
    void** v17;
    void** ebp18;
    void** v19;
    void** esi20;
    void** v21;
    void** edi22;
    void** esi23;
    void** eax24;
    int1_t below_or_equal25;
    void** eax26;
    int1_t below_or_equal27;

    v16 = reinterpret_cast<void**>(__return_address());
    v17 = ebp18;
    v19 = esi20;
    v21 = edi22;
    esi23 = reinterpret_cast<void**>(0);
    do {
        eax24 = fun_10004bb8(ecx, a2, v21, v19, v17, v16, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
        ecx = a2;
        if (eax24) 
            break;
        below_or_equal25 = reinterpret_cast<unsigned char>(g1000e1a4) <= reinterpret_cast<unsigned char>(eax24);
        if (below_or_equal25) 
            break;
        Sleep(ecx, esi23);
        eax26 = esi23 + 0x3e8;
        below_or_equal27 = reinterpret_cast<unsigned char>(eax26) <= reinterpret_cast<unsigned char>(g1000e1a4);
        if (!below_or_equal27) {
            eax26 = reinterpret_cast<void**>(0xffffffff);
        }
        esi23 = eax26;
    } while (!reinterpret_cast<int1_t>(eax26 == 0xffffffff));
    return eax24;
}

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

struct s39 {
    unsigned char f0;
    unsigned char f1;
};

int32_t IsValidCodePage = 0xca46;

void** g1000e170;

void** fun_10002e33(void** ecx, int32_t a2, void** a3) {
    void* ebp4;
    void** eax5;
    uint32_t v6;
    void** v7;
    void** ebx8;
    void** ebx9;
    void** v10;
    void** esi11;
    void** v12;
    void** edi13;
    void** eax14;
    void** edi15;
    void** v16;
    void** v17;
    uint32_t eax18;
    void** v19;
    void** v20;
    void** v21;
    void** v22;
    uint32_t ecx23;
    void** v24;
    struct s39* esi25;
    struct s39* v26;
    void* edi27;
    void* eax28;
    void** eax29;
    void** eax30;
    void*** ecx31;
    int32_t edx32;
    void** eax33;
    void** v34;
    void** v35;
    void** v36;
    int1_t zf37;
    void** v38;
    void** v39;
    void** v40;
    signed char v41;
    void** v42;
    void* eax43;
    unsigned char v44;
    void* ecx45;
    signed char v46;
    unsigned char* eax47;
    int32_t ecx48;
    void** eax49;
    void** edi50;
    void** edi51;

    ebp4 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    eax5 = g1000d050;
    v6 = reinterpret_cast<unsigned char>(eax5) ^ reinterpret_cast<uint32_t>(ebp4);
    v7 = ebx8;
    ebx9 = a3;
    v10 = esi11;
    v12 = edi13;
    eax14 = fun_10002db5(v12, v10, v7);
    edi15 = eax14;
    v16 = edi15;
    if (!edi15) 
        goto addr_10002e5e_2;
    v17 = reinterpret_cast<void**>(0);
    eax18 = 0;
    do {
        if (*reinterpret_cast<void***>(eax18 + 0x1000d600) == edi15) 
            break;
        ++v17;
        eax18 = eax18 + 48;
    } while (eax18 < 0xf0);
    goto addr_10002e8a_6;
    fun_10005bc0(ecx, ebx9 + 28, 0, 0x101, v12, v10, v7, v19, v17, v20, v21, v22);
    ecx23 = reinterpret_cast<unsigned char>(v17) * 48;
    v24 = reinterpret_cast<void**>(0);
    esi25 = reinterpret_cast<struct s39*>(ecx23 + 0x1000d610);
    v26 = esi25;
    while (1) {
        if (!esi25->f0 || !esi25->f1) {
            ++v24;
            esi25 = v26 + 4;
            v26 = esi25;
            if (reinterpret_cast<unsigned char>(v24) >= reinterpret_cast<unsigned char>(4)) 
                break;
        } else {
            edi27 = reinterpret_cast<void*>(static_cast<uint32_t>(esi25->f0));
            eax28 = reinterpret_cast<void*>(static_cast<uint32_t>(esi25->f1));
            while (reinterpret_cast<uint32_t>(edi27) <= reinterpret_cast<uint32_t>(eax28)) {
                *reinterpret_cast<unsigned char*>(reinterpret_cast<unsigned char>(ebx9) + reinterpret_cast<uint32_t>(edi27) + 29) = reinterpret_cast<unsigned char>(*reinterpret_cast<unsigned char*>(reinterpret_cast<unsigned char>(ebx9) + reinterpret_cast<uint32_t>(edi27) + 29) | *reinterpret_cast<unsigned char*>(v24 + 0x1000d5fc));
                eax28 = reinterpret_cast<void*>(static_cast<uint32_t>(esi25->f1));
                edi27 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(edi27) + 1);
            }
            edi15 = v16;
            ++esi25;
        }
    }
    *reinterpret_cast<void***>(ebx9 + 4) = edi15;
    *reinterpret_cast<void***>(ebx9 + 8) = reinterpret_cast<void**>(1);
    eax29 = fun_10002aee(v12, v10, v7);
    *reinterpret_cast<void***>(ebx9 + 12) = eax29;
    eax30 = ebx9 + 16;
    ecx31 = reinterpret_cast<void***>(ecx23 + 0x1000d604);
    edx32 = 6;
    do {
        *reinterpret_cast<void***>(eax30) = *ecx31;
        ecx31 = ecx31 + 2;
        eax30 = eax30 + 2;
        --edx32;
    } while (edx32);
    addr_10002fa5_16:
    fun_10002b81();
    addr_10002e65_17:
    addr_1000300d_18:
    eax33 = fun_10001cc4(v6 ^ reinterpret_cast<uint32_t>(ebp4), v24);
    return eax33;
    addr_10002e8a_6:
    if (edi15 == 0xfde8) 
        goto addr_1000300a_19;
    if (edi15 == 0xfde9) 
        goto addr_1000300a_19;
    v34 = reinterpret_cast<void**>(static_cast<uint32_t>(*reinterpret_cast<uint16_t*>(&edi15)));
    eax18 = reinterpret_cast<uint32_t>(IsValidCodePage(v34));
    if (!eax18) 
        goto addr_1000300a_19;
    v35 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp4) + 0xffffffe8);
    v36 = edi15;
    eax18 = reinterpret_cast<uint32_t>(GetCPInfo(v36, v35, v34));
    if (!eax18) {
        zf37 = g1000e170 == 0;
        if (!zf37) {
            addr_10002e5e_2:
            fun_10002b1d(ecx, v12, v10, v7, v38, v17);
            goto addr_10002e65_17;
        } else {
            addr_1000300a_19:
            goto addr_1000300d_18;
        }
    } else {
        fun_10005bc0(ecx, ebx9 + 28, 0, 0x101, v36, v35, v34, v12, v10, v7, v39, v17);
        *reinterpret_cast<void***>(ebx9 + 4) = edi15;
        *reinterpret_cast<void***>(ebx9 + 12) = reinterpret_cast<void**>(0);
        if (reinterpret_cast<unsigned char>(v40) <= reinterpret_cast<unsigned char>(1)) {
            *reinterpret_cast<void***>(ebx9 + 8) = reinterpret_cast<void**>(0);
        } else {
            if (v41) {
                do {
                    if (!v42) 
                        break;
                    eax43 = reinterpret_cast<void*>(static_cast<uint32_t>(v44));
                    ecx45 = reinterpret_cast<void*>(static_cast<uint32_t>(reinterpret_cast<unsigned char>(v42)));
                    while (reinterpret_cast<uint32_t>(eax43) <= reinterpret_cast<uint32_t>(ecx45)) {
                        *reinterpret_cast<unsigned char*>(reinterpret_cast<unsigned char>(ebx9) + reinterpret_cast<uint32_t>(eax43) + 29) = reinterpret_cast<unsigned char>(*reinterpret_cast<unsigned char*>(reinterpret_cast<unsigned char>(ebx9) + reinterpret_cast<uint32_t>(eax43) + 29) | 4);
                        eax43 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(eax43) + 1);
                    }
                } while (v46);
            }
            eax47 = reinterpret_cast<unsigned char*>(ebx9 + 30);
            ecx48 = 0xfe;
            do {
                *eax47 = reinterpret_cast<unsigned char>(*eax47 | 8);
                ++eax47;
                --ecx48;
            } while (ecx48);
            eax49 = fun_10002aee(v36, v35, v34);
            *reinterpret_cast<void***>(ebx9 + 12) = eax49;
            *reinterpret_cast<void***>(ebx9 + 8) = reinterpret_cast<void**>(1);
        }
        edi50 = ebx9 + 16;
        *reinterpret_cast<void***>(edi50) = reinterpret_cast<void**>(0);
        edi51 = edi50 + 4;
        *reinterpret_cast<void***>(edi51) = reinterpret_cast<void**>(0);
        *reinterpret_cast<void***>(edi51 + 4) = reinterpret_cast<void**>(0);
        goto addr_10002fa5_16;
    }
}

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

int32_t EnterCriticalSection = 0xcc6e;

void fun_10006df1(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11) {
    void** esi12;
    void** ebp13;
    int32_t eax14;

    if (!*reinterpret_cast<int32_t*>(reinterpret_cast<unsigned char>(a2) * 8 + 0x1000dc40) && (eax14 = fun_10006d2f(ecx, a2, esi12, ebp13, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11), ecx = a2, !eax14)) {
        fun_10003e6f(ecx, 17);
        ecx = reinterpret_cast<void**>(17);
    }
    EnterCriticalSection(ecx);
    goto ebp13;
}

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

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

struct s42 {
    signed char[104] pad104;
    void** f104;
    signed char[7] pad112;
    unsigned char f112;
};

void** g1000e180;

void** g1000e184;

void** g1000e188;

struct s43 {
    signed char[268489712] pad268489712;
    signed char f268489712;
};

struct s44 {
    signed char[268489976] pad268489976;
    signed char f268489976;
};

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

void fun_1000301c(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15) {
    void** v16;
    int32_t ebp17;
    void** eax18;
    int32_t ebp19;
    void** ebx20;
    void** eax21;
    struct s40* ebp22;
    int32_t ebp23;
    void** eax24;
    void** ebx25;
    void** ecx26;
    void** esi27;
    void** edi28;
    int32_t v29;
    struct s41* ebp30;
    void** eax31;
    int32_t ebp32;
    void** eax33;
    struct s42* esi34;
    int32_t ebp35;
    void** v36;
    int32_t eax37;
    void** v38;
    void** v39;
    int32_t edi40;
    int1_t zf41;
    int32_t ebp42;
    int32_t eax43;
    int32_t ebp44;
    struct s43* eax45;
    int32_t ebp46;
    struct s44* eax47;
    int32_t ebp48;
    void** v49;
    int32_t eax50;
    void** eax51;
    int32_t ebp52;

    v16 = reinterpret_cast<void**>(__return_address());
    fun_10004570(0x1000c3e0, 20, v16);
    *reinterpret_cast<uint32_t*>(ebp17 - 32) = 0xffffffff;
    eax18 = fun_100036bd(ecx, 0x1000c3e0, 20, v16, a2, a3, a4, a5, a6);
    *reinterpret_cast<void***>(ebp19 - 36) = eax18;
    fun_10002d11(ecx, 0x1000c3e0, 20, v16, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
    ebx20 = *reinterpret_cast<void***>(eax18 + 0x68);
    eax21 = fun_10002db5(0x1000c3e0, 20, v16);
    ebp22->f8 = eax21;
    if (eax21 == *reinterpret_cast<void***>(ebx20 + 4)) {
        *reinterpret_cast<uint32_t*>(ebp23 - 32) = 0;
        goto addr_100031ad_3;
    }
    eax24 = fun_10003ae8(ecx, 0x220, 0x1000c3e0, 20, v16, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
    ecx = reinterpret_cast<void**>(0x220);
    ebx25 = eax24;
    if (!ebx25) 
        goto addr_100031ad_3;
    ecx26 = reinterpret_cast<void**>(0x88);
    esi27 = *reinterpret_cast<void***>(eax18 + 0x68);
    edi28 = ebx25;
    while (ecx26) {
        --ecx26;
        *reinterpret_cast<void***>(edi28) = *reinterpret_cast<void***>(esi27);
        edi28 = edi28 + 4;
        esi27 = esi27 + 4;
    }
    *reinterpret_cast<void***>(ebx25) = reinterpret_cast<void**>(0);
    v29 = ebp30->f8;
    eax31 = fun_10002e33(ecx26, v29, ebx25);
    ecx = ebx25;
    *reinterpret_cast<void***>(ebp32 - 32) = eax31;
    if (!eax31) 
        goto addr_1000308c_9;
    if (reinterpret_cast<int1_t>(eax31 == 0xffffffff)) {
        if (ebx25 != 0x1000d1d0) {
            fun_10002416(ecx, ebx25, 0x1000c3e0, 20, v16, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = ebx25;
        }
        eax33 = fun_10002896(ecx, 0x1000c3e0, 20, v16, a2, a3, a4, a5, a6, a7, a8);
        *reinterpret_cast<void***>(eax33) = reinterpret_cast<void**>(22);
        goto addr_100031ad_3;
    }
    addr_1000308c_9:
    esi34 = *reinterpret_cast<struct s42**>(ebp35 - 36);
    v36 = esi34->f104;
    eax37 = reinterpret_cast<int32_t>(InterlockedDecrement(ecx, v36));
    if (!eax37 && esi34->f104 != 0x1000d1d0) {
        v38 = esi34->f104;
        fun_10002416(ecx, v38, v36, 0x1000c3e0, 20, v16, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
        ecx = v38;
    }
    esi34->f104 = ebx25;
    v39 = ebx25;
    edi40 = InterlockedIncrement;
    edi40(ecx, v39, v36);
    if (esi34->f112 & 2 || (zf41 = (*reinterpret_cast<unsigned char*>(&g1000d6f0) & 1) == 0, !zf41)) {
        addr_100031ad_3:
        fun_100045b5(ecx, 0x1000c3e0, 20, v16, a2, a3);
        goto 0x1000c3e0;
    } else {
        fun_10006df1(ecx, 13, v39, v36, 0x1000c3e0, 20, v16, a2, a3, a4, a5);
        ecx = reinterpret_cast<void**>(13);
        *reinterpret_cast<uint32_t*>(ebp42 - 4) = 0;
        g1000e180 = *reinterpret_cast<void***>(ebx25 + 4);
        g1000e184 = *reinterpret_cast<void***>(ebx25 + 8);
        g1000e188 = *reinterpret_cast<void***>(ebx25 + 12);
        eax43 = 0;
        while (*reinterpret_cast<int32_t*>(ebp44 - 28) = eax43, eax43 < 5) {
            *reinterpret_cast<int16_t*>(&ecx) = *reinterpret_cast<int16_t*>(reinterpret_cast<uint32_t>(ebx25 + eax43 * 2) + 16);
            *reinterpret_cast<int16_t*>(eax43 * 2 + 0x1000e174) = *reinterpret_cast<int16_t*>(&ecx);
            ++eax43;
        }
        eax45 = reinterpret_cast<struct s43*>(0);
        while (*reinterpret_cast<struct s43**>(ebp46 - 28) = eax45, reinterpret_cast<int32_t>(eax45) < 0x101) {
            *reinterpret_cast<signed char*>(&ecx) = *reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(eax45) + reinterpret_cast<unsigned char>(ebx25) + 28);
            *reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(eax45) + 0x1000d3f0) = *reinterpret_cast<signed char*>(&ecx);
            eax45 = reinterpret_cast<struct s43*>(reinterpret_cast<int32_t>(eax45) + 1);
        }
        eax47 = reinterpret_cast<struct s44*>(0);
        while (*reinterpret_cast<struct s44**>(ebp48 - 28) = eax47, reinterpret_cast<int32_t>(eax47) < 0x100) {
            *reinterpret_cast<signed char*>(&ecx) = *reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(eax47) + reinterpret_cast<unsigned char>(ebx25) + 0x11d);
            *reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(eax47) + 0x1000d4f8) = *reinterpret_cast<signed char*>(&ecx);
            eax47 = reinterpret_cast<struct s44*>(reinterpret_cast<int32_t>(eax47) + 1);
        }
        v49 = image_base_;
        eax50 = reinterpret_cast<int32_t>(InterlockedDecrement(ecx, v49, v39, v36));
        if (eax50) 
            goto addr_10003166_26;
        eax51 = image_base_;
        if (eax51 != 0x1000d1d0) 
            goto addr_1000315f_28;
    }
    addr_10003166_26:
    image_base_ = ebx25;
    edi40(ecx, ebx25, v49, v39, v36);
    *reinterpret_cast<int32_t*>(ebp52 - 4) = -2;
    fun_1000317d(ecx, ebx25, v49, v39, v36);
    goto addr_100031ad_3;
    addr_1000315f_28:
    fun_10002416(ecx, eax51, v49, v39, v36, 0x1000c3e0, 20, v16, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
    ecx = eax51;
    goto addr_10003166_26;
}

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

void fun_100031d4(int32_t ecx, void** a2) {
    int32_t v3;
    int32_t ebx4;
    int32_t esi5;
    void** v6;
    void** v7;
    void** v8;
    void** v9;
    struct s45* ebx10;
    int32_t v11;
    void** v12;
    void** v13;

    v3 = ebx4;
    esi5 = InterlockedIncrement;
    esi5();
    if (*reinterpret_cast<void***>(a2 + 0xb0)) {
        v6 = *reinterpret_cast<void***>(a2 + 0xb0);
        esi5(v6);
    }
    if (*reinterpret_cast<void***>(a2 + 0xb8)) {
        v7 = *reinterpret_cast<void***>(a2 + 0xb8);
        esi5(v7);
    }
    if (*reinterpret_cast<void***>(a2 + 0xb4)) {
        v8 = *reinterpret_cast<void***>(a2 + 0xb4);
        esi5(v8);
    }
    if (*reinterpret_cast<void***>(a2 + 0xc0)) {
        v9 = *reinterpret_cast<void***>(a2 + 0xc0);
        esi5(v9);
    }
    ebx10 = reinterpret_cast<struct s45*>(a2 + 80);
    v11 = 6;
    do {
        if (*reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(ebx10) - 8) != "C" && ebx10->f0) {
            v12 = ebx10->f0;
            esi5(v12);
        }
        if (*reinterpret_cast<void***>(reinterpret_cast<uint32_t>(ebx10) - 4) && ebx10->f4) {
            v13 = ebx10->f4;
            esi5(v13);
        }
        ebx10 = reinterpret_cast<struct s45*>(reinterpret_cast<uint32_t>(ebx10) + 16);
        --v11;
    } while (v11);
    esi5();
    goto v3;
}

void** fun_10003263(void** ecx, void** a2) {
    void** edi3;
    int32_t esi4;
    void** v5;
    void** v6;
    void** v7;
    void** v8;
    struct s45* ebx9;
    int32_t v10;
    void** v11;
    void** v12;

    edi3 = a2;
    if (edi3) {
        esi4 = InterlockedDecrement;
        esi4();
        if (*reinterpret_cast<void***>(edi3 + 0xb0)) {
            v5 = *reinterpret_cast<void***>(edi3 + 0xb0);
            esi4(v5);
        }
        if (*reinterpret_cast<void***>(edi3 + 0xb8)) {
            v6 = *reinterpret_cast<void***>(edi3 + 0xb8);
            esi4(v6);
        }
        if (*reinterpret_cast<void***>(edi3 + 0xb4)) {
            v7 = *reinterpret_cast<void***>(edi3 + 0xb4);
            esi4(v7);
        }
        if (*reinterpret_cast<void***>(edi3 + 0xc0)) {
            v8 = *reinterpret_cast<void***>(edi3 + 0xc0);
            esi4(v8);
        }
        ebx9 = reinterpret_cast<struct s45*>(edi3 + 80);
        v10 = 6;
        do {
            if (*reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(ebx9) - 8) != "C" && ebx9->f0) {
                v11 = ebx9->f0;
                esi4(v11);
            }
            if (*reinterpret_cast<void***>(reinterpret_cast<uint32_t>(ebx9) - 4) && ebx9->f4) {
                v12 = ebx9->f4;
                esi4(v12);
            }
            ebx9 = reinterpret_cast<struct s45*>(reinterpret_cast<uint32_t>(ebx9) + 16);
            --v10;
        } while (v10);
        esi4();
    }
    return edi3;
}

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

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

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

void** fun_100032fc(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13) {
    void** v14;
    void** v15;
    void** ebp16;
    void** v17;
    void** ebx18;
    void** v19;
    void** esi20;
    void** esi21;
    void** eax22;
    void** v23;
    void** edi24;
    void** v25;
    void** v26;
    void** v27;
    void** v28;
    void** v29;
    void** v30;
    void** v31;
    void** v32;
    void** v33;
    void** v34;
    void** v35;
    void** v36;
    struct s45* edi37;
    void** v38;
    void** v39;
    void** v40;
    void** eax41;

    v14 = reinterpret_cast<void**>(__return_address());
    v15 = ebp16;
    v17 = ebx18;
    v19 = esi20;
    esi21 = a2;
    eax22 = *reinterpret_cast<void***>(esi21 + 0xbc);
    v23 = edi24;
    if (eax22 && (eax22 != 0x1000dd68 && (*reinterpret_cast<void***>(esi21 + 0xb0) && !*reinterpret_cast<void***>(*reinterpret_cast<void***>(esi21 + 0xb0))))) {
        if (*reinterpret_cast<void***>(esi21 + 0xb8) && !*reinterpret_cast<void***>(*reinterpret_cast<void***>(esi21 + 0xb8))) {
            v25 = *reinterpret_cast<void***>(esi21 + 0xb8);
            fun_10002416(ecx, v25, v23, v19, v17, v15, v14, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
            v26 = *reinterpret_cast<void***>(esi21 + 0xbc);
            fun_10007204(ecx, v26, v25, v23, v19, v17, v15, v14, a2, a3, a4, a5, a6, a7, a8);
            ecx = v25;
        }
        if (*reinterpret_cast<void***>(esi21 + 0xb4) && !*reinterpret_cast<void***>(*reinterpret_cast<void***>(esi21 + 0xb4))) {
            v27 = *reinterpret_cast<void***>(esi21 + 0xb4);
            fun_10002416(ecx, v27, v23, v19, v17, v15, v14, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
            v28 = *reinterpret_cast<void***>(esi21 + 0xbc);
            fun_1000719b(ecx, v28, v27, v23, v19, v17, v15, v14, a2, a3, a4, a5, a6, a7, a8);
            ecx = v27;
        }
        v29 = *reinterpret_cast<void***>(esi21 + 0xb0);
        fun_10002416(ecx, v29, v23, v19, v17, v15, v14, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
        v30 = *reinterpret_cast<void***>(esi21 + 0xbc);
        fun_10002416(ecx, v30, v29, v23, v19, v17, v15, v14, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
        ecx = v29;
    }
    if (*reinterpret_cast<void***>(esi21 + 0xc0) && !*reinterpret_cast<void***>(*reinterpret_cast<void***>(esi21 + 0xc0))) {
        v31 = *reinterpret_cast<void***>(esi21 + 0xc4) - 0xfe;
        fun_10002416(ecx, v31, v23, v19, v17, v15, v14, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
        v32 = *reinterpret_cast<void***>(esi21 + 0xcc) - 0x80;
        fun_10002416(ecx, v32, v31, v23, v19, v17, v15, v14, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
        v33 = *reinterpret_cast<void***>(esi21 + 0xd0) - 0x80;
        fun_10002416(ecx, v33, v32, v31, v23, v19, v17, v15, v14, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
        v34 = *reinterpret_cast<void***>(esi21 + 0xc0);
        fun_10002416(ecx, v34, v33, v32, v31, v23, v19, v17, v15, v14, a2, a3, a4, a5, a6, a7, a8, a9, a10);
    }
    if (*reinterpret_cast<void***>(esi21 + 0xd4) != 0x1000d6f8 && !*reinterpret_cast<void***>(*reinterpret_cast<void***>(esi21 + 0xd4) + 0xb4)) {
        v35 = *reinterpret_cast<void***>(esi21 + 0xd4);
        fun_10006e24(ecx, v35, v23, v19, v17, v15, v14, a2, a3, a4, a5, a6, a7, a8, a9);
        v36 = *reinterpret_cast<void***>(esi21 + 0xd4);
        fun_10002416(ecx, v36, v35, v23, v19, v17, v15, v14, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
        ecx = v35;
    }
    edi37 = reinterpret_cast<struct s45*>(esi21 + 80);
    v38 = reinterpret_cast<void**>(6);
    do {
        if (*reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(edi37) - 8) != "C" && (edi37->f0 && !*reinterpret_cast<void***>(edi37->f0))) {
            v39 = edi37->f0;
            fun_10002416(ecx, v39, v23, v19, v17, v15, v14, v38, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
            ecx = v39;
        }
        if (*reinterpret_cast<void***>(reinterpret_cast<uint32_t>(edi37) - 4) && (edi37->f4 && !*reinterpret_cast<void***>(edi37->f4))) {
            v40 = edi37->f4;
            fun_10002416(ecx, v40, v23, v19, v17, v15, v14, v38, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
            ecx = v40;
        }
        edi37 = reinterpret_cast<struct s45*>(reinterpret_cast<uint32_t>(edi37) + 16);
        --v38;
    } while (v38);
    eax41 = fun_10002416(ecx, esi21, v23, v19, v17, v15, v14, v38, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
    return eax41;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

void** fun_10007204(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15) {
    int1_t zf16;
    void** v17;
    void** esi18;
    void** ebp19;
    int1_t zf20;
    void** v21;
    int1_t zf22;
    void** v23;
    int1_t zf24;
    void** v25;
    int1_t zf26;
    void** v27;
    int1_t zf28;
    void** v29;
    int1_t zf30;
    void** v31;
    int1_t zf32;
    void** v33;
    int1_t zf34;
    void** v35;
    int1_t zf36;
    void** v37;
    int1_t zf38;
    void** v39;
    void** eax40;
    int1_t zf41;
    void** v42;
    int1_t zf43;
    void** v44;

    if (a2) {
        zf16 = *reinterpret_cast<void***>(a2 + 12) == image_base_;
        if (!zf16) {
            v17 = *reinterpret_cast<void***>(a2 + 12);
            fun_10002416(ecx, v17, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v17;
        }
        zf20 = *reinterpret_cast<void***>(a2 + 16) == image_base_;
        if (!zf20) {
            v21 = *reinterpret_cast<void***>(a2 + 16);
            fun_10002416(ecx, v21, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v21;
        }
        zf22 = *reinterpret_cast<void***>(a2 + 20) == image_base_;
        if (!zf22) {
            v23 = *reinterpret_cast<void***>(a2 + 20);
            fun_10002416(ecx, v23, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v23;
        }
        zf24 = *reinterpret_cast<void***>(a2 + 24) == image_base_;
        if (!zf24) {
            v25 = *reinterpret_cast<void***>(a2 + 24);
            fun_10002416(ecx, v25, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v25;
        }
        zf26 = *reinterpret_cast<void***>(a2 + 28) == image_base_;
        if (!zf26) {
            v27 = *reinterpret_cast<void***>(a2 + 28);
            fun_10002416(ecx, v27, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v27;
        }
        zf28 = *reinterpret_cast<void***>(a2 + 32) == image_base_;
        if (!zf28) {
            v29 = *reinterpret_cast<void***>(a2 + 32);
            fun_10002416(ecx, v29, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v29;
        }
        zf30 = *reinterpret_cast<void***>(a2 + 36) == image_base_;
        if (!zf30) {
            v31 = *reinterpret_cast<void***>(a2 + 36);
            fun_10002416(ecx, v31, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v31;
        }
        zf32 = *reinterpret_cast<void***>(a2 + 56) == image_base_;
        if (!zf32) {
            v33 = *reinterpret_cast<void***>(a2 + 56);
            fun_10002416(ecx, v33, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v33;
        }
        zf34 = *reinterpret_cast<void***>(a2 + 60) == image_base_;
        if (!zf34) {
            v35 = *reinterpret_cast<void***>(a2 + 60);
            fun_10002416(ecx, v35, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v35;
        }
        zf36 = *reinterpret_cast<void***>(a2 + 64) == image_base_;
        if (!zf36) {
            v37 = *reinterpret_cast<void***>(a2 + 64);
            fun_10002416(ecx, v37, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v37;
        }
        zf38 = *reinterpret_cast<void***>(a2 + 68) == image_base_;
        if (!zf38) {
            v39 = *reinterpret_cast<void***>(a2 + 68);
            fun_10002416(ecx, v39, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v39;
        }
        eax40 = *reinterpret_cast<void***>(a2 + 72);
        zf41 = eax40 == image_base_;
        if (!zf41) {
            v42 = eax40;
            eax40 = fun_10002416(ecx, v42, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v42;
        }
        zf43 = *reinterpret_cast<void***>(a2 + 76) == image_base_;
        if (!zf43) {
            v44 = *reinterpret_cast<void***>(a2 + 76);
            eax40 = fun_10002416(ecx, v44, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
        }
    }
    return eax40;
}

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

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

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

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

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

void** fun_1000719b(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15) {
    int1_t zf16;
    void** v17;
    void** esi18;
    void** ebp19;
    int1_t zf20;
    void** v21;
    int1_t zf22;
    void** v23;
    void** eax24;
    int1_t zf25;
    void** v26;
    int1_t zf27;
    void** v28;

    if (a2) {
        zf16 = *reinterpret_cast<void***>(a2) == image_base_;
        if (!zf16) {
            v17 = *reinterpret_cast<void***>(a2);
            fun_10002416(ecx, v17, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v17;
        }
        zf20 = *reinterpret_cast<void***>(a2 + 4) == image_base_;
        if (!zf20) {
            v21 = *reinterpret_cast<void***>(a2 + 4);
            fun_10002416(ecx, v21, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v21;
        }
        zf22 = *reinterpret_cast<void***>(a2 + 8) == image_base_;
        if (!zf22) {
            v23 = *reinterpret_cast<void***>(a2 + 8);
            fun_10002416(ecx, v23, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v23;
        }
        eax24 = *reinterpret_cast<void***>(a2 + 48);
        zf25 = eax24 == image_base_;
        if (!zf25) {
            v26 = eax24;
            eax24 = fun_10002416(ecx, v26, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v26;
        }
        zf27 = *reinterpret_cast<void***>(a2 + 52) == image_base_;
        if (!zf27) {
            v28 = *reinterpret_cast<void***>(a2 + 52);
            eax24 = fun_10002416(ecx, v28, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
        }
    }
    return eax24;
}

void** fun_10006e24(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15) {
    void** v16;
    void** esi17;
    void** ebp18;
    void** v19;
    void** v20;
    void** v21;
    void** v22;
    void** v23;
    void** v24;
    void** v25;
    void** v26;
    void** v27;
    void** v28;
    void** v29;
    void** v30;
    void** v31;
    void** v32;
    void** v33;
    void** v34;
    void** v35;
    void** v36;
    void** v37;
    void** v38;
    void** v39;
    void** v40;
    void** v41;
    void** v42;
    void** v43;
    void** v44;
    void** v45;
    void** v46;
    void** v47;
    void** v48;
    void** v49;
    void** v50;
    void** v51;
    void** v52;
    void** v53;
    void** v54;
    void** v55;
    void** v56;
    void** v57;
    void** v58;
    void** v59;
    void** v60;
    void** v61;
    void** v62;
    void** v63;
    void** v64;
    void** v65;
    void** v66;
    void** v67;
    void** v68;
    void** v69;
    void** v70;
    void** v71;
    void** v72;
    void** v73;
    void** v74;
    void** v75;
    void** v76;
    void** v77;
    void** v78;
    void** v79;
    void** v80;
    void** v81;
    void** v82;
    void** v83;
    void** v84;
    void** v85;
    void** v86;
    void** v87;
    void** v88;
    void** v89;
    void** v90;
    void** v91;
    void** v92;
    void** v93;
    void** v94;
    void** v95;
    void** v96;
    void** v97;
    void** v98;
    void** v99;
    void** v100;
    void** v101;
    void** v102;
    void** v103;
    void** eax104;

    if (a2) {
        v16 = *reinterpret_cast<void***>(a2 + 4);
        fun_10002416(ecx, v16, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
        v19 = *reinterpret_cast<void***>(a2 + 8);
        fun_10002416(ecx, v19, v16, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
        v20 = *reinterpret_cast<void***>(a2 + 12);
        fun_10002416(ecx, v20, v19, v16, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
        v21 = *reinterpret_cast<void***>(a2 + 16);
        fun_10002416(ecx, v21, v20, v19, v16, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
        v22 = *reinterpret_cast<void***>(a2 + 20);
        fun_10002416(ecx, v22, v21, v20, v19, v16, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
        v23 = *reinterpret_cast<void***>(a2 + 24);
        fun_10002416(ecx, v23, v22, v21, v20, v19, v16, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10);
        v24 = *reinterpret_cast<void***>(a2);
        fun_10002416(ecx, v24, v23, v22, v21, v20, v19, v16, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
        v25 = *reinterpret_cast<void***>(a2 + 32);
        fun_10002416(ecx, v25, v24, v23, v22, v21, v20, v19, v16, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8);
        v26 = *reinterpret_cast<void***>(a2 + 36);
        fun_10002416(ecx, v26, v25, v24, v23, v22, v21, v20, v19, v16, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7);
        v27 = *reinterpret_cast<void***>(a2 + 40);
        fun_10002416(ecx, v27, v26, v25, v24, v23, v22, v21, v20, v19, v16, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6);
        v28 = *reinterpret_cast<void***>(a2 + 44);
        fun_10002416(ecx, v28, v27, v26, v25, v24, v23, v22, v21, v20, v19, v16, esi17, ebp18, __return_address(), a2, a3, a4, a5);
        v29 = *reinterpret_cast<void***>(a2 + 48);
        fun_10002416(ecx, v29, v28, v27, v26, v25, v24, v23, v22, v21, v20, v19, v16, esi17, ebp18, __return_address(), a2, a3, a4);
        v30 = *reinterpret_cast<void***>(a2 + 52);
        fun_10002416(ecx, v30, v29, v28, v27, v26, v25, v24, v23, v22, v21, v20, v19, v16, esi17, ebp18, __return_address(), a2, a3);
        v31 = *reinterpret_cast<void***>(a2 + 28);
        fun_10002416(ecx, v31, v30, v29, v28, v27, v26, v25, v24, v23, v22, v21, v20, v19, v16, esi17, ebp18, __return_address(), a2);
        v32 = *reinterpret_cast<void***>(a2 + 56);
        fun_10002416(ecx, v32, v31, v30, v29, v28, v27, v26, v25, v24, v23, v22, v21, v20, v19, v16, esi17, ebp18, __return_address());
        v33 = *reinterpret_cast<void***>(a2 + 60);
        fun_10002416(ecx, v33, v32, v31, v30, v29, v28, v27, v26, v25, v24, v23, v22, v21, v20, v19, v16, esi17, ebp18);
        v34 = *reinterpret_cast<void***>(a2 + 64);
        fun_10002416(ecx, v34, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
        v35 = *reinterpret_cast<void***>(a2 + 68);
        fun_10002416(ecx, v35, v34, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
        v36 = *reinterpret_cast<void***>(a2 + 72);
        fun_10002416(ecx, v36, v35, v34, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
        v37 = *reinterpret_cast<void***>(a2 + 76);
        fun_10002416(ecx, v37, v36, v35, v34, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
        v38 = *reinterpret_cast<void***>(a2 + 80);
        fun_10002416(ecx, v38, v37, v36, v35, v34, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
        v39 = *reinterpret_cast<void***>(a2 + 84);
        fun_10002416(ecx, v39, v38, v37, v36, v35, v34, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10);
        v40 = *reinterpret_cast<void***>(a2 + 88);
        fun_10002416(ecx, v40, v39, v38, v37, v36, v35, v34, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
        v41 = *reinterpret_cast<void***>(a2 + 92);
        fun_10002416(ecx, v41, v40, v39, v38, v37, v36, v35, v34, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8);
        v42 = *reinterpret_cast<void***>(a2 + 96);
        fun_10002416(ecx, v42, v41, v40, v39, v38, v37, v36, v35, v34, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7);
        v43 = *reinterpret_cast<void***>(a2 + 100);
        fun_10002416(ecx, v43, v42, v41, v40, v39, v38, v37, v36, v35, v34, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6);
        v44 = *reinterpret_cast<void***>(a2 + 0x68);
        fun_10002416(ecx, v44, v43, v42, v41, v40, v39, v38, v37, v36, v35, v34, esi17, ebp18, __return_address(), a2, a3, a4, a5);
        v45 = *reinterpret_cast<void***>(a2 + 0x6c);
        fun_10002416(ecx, v45, v44, v43, v42, v41, v40, v39, v38, v37, v36, v35, v34, esi17, ebp18, __return_address(), a2, a3, a4);
        v46 = *reinterpret_cast<void***>(a2 + 0x70);
        fun_10002416(ecx, v46, v45, v44, v43, v42, v41, v40, v39, v38, v37, v36, v35, v34, esi17, ebp18, __return_address(), a2, a3);
        v47 = *reinterpret_cast<void***>(a2 + 0x74);
        fun_10002416(ecx, v47, v46, v45, v44, v43, v42, v41, v40, v39, v38, v37, v36, v35, v34, esi17, ebp18, __return_address(), a2);
        v48 = *reinterpret_cast<void***>(a2 + 0x78);
        fun_10002416(ecx, v48, v47, v46, v45, v44, v43, v42, v41, v40, v39, v38, v37, v36, v35, v34, esi17, ebp18, __return_address());
        v49 = *reinterpret_cast<void***>(a2 + 0x7c);
        fun_10002416(ecx, v49, v48, v47, v46, v45, v44, v43, v42, v41, v40, v39, v38, v37, v36, v35, v34, esi17, ebp18);
        v50 = *reinterpret_cast<void***>(a2 + 0x80);
        fun_10002416(ecx, v50, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
        v51 = *reinterpret_cast<void***>(a2 + 0x84);
        fun_10002416(ecx, v51, v50, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
        v52 = *reinterpret_cast<void***>(a2 + 0x88);
        fun_10002416(ecx, v52, v51, v50, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
        v53 = *reinterpret_cast<void***>(a2 + 0x8c);
        fun_10002416(ecx, v53, v52, v51, v50, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
        v54 = *reinterpret_cast<void***>(a2 + 0x90);
        fun_10002416(ecx, v54, v53, v52, v51, v50, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
        v55 = *reinterpret_cast<void***>(a2 + 0x94);
        fun_10002416(ecx, v55, v54, v53, v52, v51, v50, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10);
        v56 = *reinterpret_cast<void***>(a2 + 0x98);
        fun_10002416(ecx, v56, v55, v54, v53, v52, v51, v50, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
        v57 = *reinterpret_cast<void***>(a2 + 0x9c);
        fun_10002416(ecx, v57, v56, v55, v54, v53, v52, v51, v50, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8);
        v58 = *reinterpret_cast<void***>(a2 + 0xa0);
        fun_10002416(ecx, v58, v57, v56, v55, v54, v53, v52, v51, v50, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7);
        v59 = *reinterpret_cast<void***>(a2 + 0xa4);
        fun_10002416(ecx, v59, v58, v57, v56, v55, v54, v53, v52, v51, v50, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6);
        v60 = *reinterpret_cast<void***>(a2 + 0xa8);
        fun_10002416(ecx, v60, v59, v58, v57, v56, v55, v54, v53, v52, v51, v50, esi17, ebp18, __return_address(), a2, a3, a4, a5);
        v61 = *reinterpret_cast<void***>(a2 + 0xbc);
        fun_10002416(ecx, v61, v60, v59, v58, v57, v56, v55, v54, v53, v52, v51, v50, esi17, ebp18, __return_address(), a2, a3, a4);
        v62 = *reinterpret_cast<void***>(a2 + 0xc0);
        fun_10002416(ecx, v62, v61, v60, v59, v58, v57, v56, v55, v54, v53, v52, v51, v50, esi17, ebp18, __return_address(), a2, a3);
        v63 = *reinterpret_cast<void***>(a2 + 0xc4);
        fun_10002416(ecx, v63, v62, v61, v60, v59, v58, v57, v56, v55, v54, v53, v52, v51, v50, esi17, ebp18, __return_address(), a2);
        v64 = *reinterpret_cast<void***>(a2 + 0xc8);
        fun_10002416(ecx, v64, v63, v62, v61, v60, v59, v58, v57, v56, v55, v54, v53, v52, v51, v50, esi17, ebp18, __return_address());
        v65 = *reinterpret_cast<void***>(a2 + 0xcc);
        fun_10002416(ecx, v65, v64, v63, v62, v61, v60, v59, v58, v57, v56, v55, v54, v53, v52, v51, v50, esi17, ebp18);
        v66 = *reinterpret_cast<void***>(a2 + 0xd0);
        fun_10002416(ecx, v66, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
        v67 = *reinterpret_cast<void***>(a2 + 0xb8);
        fun_10002416(ecx, v67, v66, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
        v68 = *reinterpret_cast<void***>(a2 + 0xd8);
        fun_10002416(ecx, v68, v67, v66, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
        v69 = *reinterpret_cast<void***>(a2 + 0xdc);
        fun_10002416(ecx, v69, v68, v67, v66, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
        v70 = *reinterpret_cast<void***>(a2 + 0xe0);
        fun_10002416(ecx, v70, v69, v68, v67, v66, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
        v71 = *reinterpret_cast<void***>(a2 + 0xe4);
        fun_10002416(ecx, v71, v70, v69, v68, v67, v66, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10);
        v72 = *reinterpret_cast<void***>(a2 + 0xe8);
        fun_10002416(ecx, v72, v71, v70, v69, v68, v67, v66, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
        v73 = *reinterpret_cast<void***>(a2 + 0xec);
        fun_10002416(ecx, v73, v72, v71, v70, v69, v68, v67, v66, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8);
        v74 = *reinterpret_cast<void***>(a2 + 0xd4);
        fun_10002416(ecx, v74, v73, v72, v71, v70, v69, v68, v67, v66, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7);
        v75 = *reinterpret_cast<void***>(a2 + 0xf0);
        fun_10002416(ecx, v75, v74, v73, v72, v71, v70, v69, v68, v67, v66, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6);
        v76 = *reinterpret_cast<void***>(a2 + 0xf4);
        fun_10002416(ecx, v76, v75, v74, v73, v72, v71, v70, v69, v68, v67, v66, esi17, ebp18, __return_address(), a2, a3, a4, a5);
        v77 = *reinterpret_cast<void***>(a2 + 0xf8);
        fun_10002416(ecx, v77, v76, v75, v74, v73, v72, v71, v70, v69, v68, v67, v66, esi17, ebp18, __return_address(), a2, a3, a4);
        v78 = *reinterpret_cast<void***>(a2 + 0xfc);
        fun_10002416(ecx, v78, v77, v76, v75, v74, v73, v72, v71, v70, v69, v68, v67, v66, esi17, ebp18, __return_address(), a2, a3);
        v79 = *reinterpret_cast<void***>(a2 + 0x100);
        fun_10002416(ecx, v79, v78, v77, v76, v75, v74, v73, v72, v71, v70, v69, v68, v67, v66, esi17, ebp18, __return_address(), a2);
        v80 = *reinterpret_cast<void***>(a2 + 0x104);
        fun_10002416(ecx, v80, v79, v78, v77, v76, v75, v74, v73, v72, v71, v70, v69, v68, v67, v66, esi17, ebp18, __return_address());
        v81 = *reinterpret_cast<void***>(a2 + 0x108);
        fun_10002416(ecx, v81, v80, v79, v78, v77, v76, v75, v74, v73, v72, v71, v70, v69, v68, v67, v66, esi17, ebp18);
        v82 = *reinterpret_cast<void***>(a2 + 0x10c);
        fun_10002416(ecx, v82, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
        v83 = *reinterpret_cast<void***>(a2 + 0x110);
        fun_10002416(ecx, v83, v82, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
        v84 = *reinterpret_cast<void***>(a2 + 0x114);
        fun_10002416(ecx, v84, v83, v82, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
        v85 = *reinterpret_cast<void***>(a2 + 0x118);
        fun_10002416(ecx, v85, v84, v83, v82, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
        v86 = *reinterpret_cast<void***>(a2 + 0x11c);
        fun_10002416(ecx, v86, v85, v84, v83, v82, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
        v87 = *reinterpret_cast<void***>(a2 + 0x120);
        fun_10002416(ecx, v87, v86, v85, v84, v83, v82, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10);
        v88 = *reinterpret_cast<void***>(a2 + 0x124);
        fun_10002416(ecx, v88, v87, v86, v85, v84, v83, v82, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
        v89 = *reinterpret_cast<void***>(a2 + 0x128);
        fun_10002416(ecx, v89, v88, v87, v86, v85, v84, v83, v82, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8);
        v90 = *reinterpret_cast<void***>(a2 + 0x12c);
        fun_10002416(ecx, v90, v89, v88, v87, v86, v85, v84, v83, v82, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7);
        v91 = *reinterpret_cast<void***>(a2 + 0x130);
        fun_10002416(ecx, v91, v90, v89, v88, v87, v86, v85, v84, v83, v82, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6);
        v92 = *reinterpret_cast<void***>(a2 + 0x134);
        fun_10002416(ecx, v92, v91, v90, v89, v88, v87, v86, v85, v84, v83, v82, esi17, ebp18, __return_address(), a2, a3, a4, a5);
        v93 = *reinterpret_cast<void***>(a2 + 0x138);
        fun_10002416(ecx, v93, v92, v91, v90, v89, v88, v87, v86, v85, v84, v83, v82, esi17, ebp18, __return_address(), a2, a3, a4);
        v94 = *reinterpret_cast<void***>(a2 + 0x13c);
        fun_10002416(ecx, v94, v93, v92, v91, v90, v89, v88, v87, v86, v85, v84, v83, v82, esi17, ebp18, __return_address(), a2, a3);
        v95 = *reinterpret_cast<void***>(a2 + 0x140);
        fun_10002416(ecx, v95, v94, v93, v92, v91, v90, v89, v88, v87, v86, v85, v84, v83, v82, esi17, ebp18, __return_address(), a2);
        v96 = *reinterpret_cast<void***>(a2 + 0x144);
        fun_10002416(ecx, v96, v95, v94, v93, v92, v91, v90, v89, v88, v87, v86, v85, v84, v83, v82, esi17, ebp18, __return_address());
        v97 = *reinterpret_cast<void***>(a2 + 0x148);
        fun_10002416(ecx, v97, v96, v95, v94, v93, v92, v91, v90, v89, v88, v87, v86, v85, v84, v83, v82, esi17, ebp18);
        v98 = *reinterpret_cast<void***>(a2 + 0x14c);
        fun_10002416(ecx, v98, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
        v99 = *reinterpret_cast<void***>(a2 + 0x150);
        fun_10002416(ecx, v99, v98, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
        v100 = *reinterpret_cast<void***>(a2 + 0x154);
        fun_10002416(ecx, v100, v99, v98, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
        v101 = *reinterpret_cast<void***>(a2 + 0x158);
        fun_10002416(ecx, v101, v100, v99, v98, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
        v102 = *reinterpret_cast<void***>(a2 + 0x15c);
        fun_10002416(ecx, v102, v101, v100, v99, v98, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
        v103 = *reinterpret_cast<void***>(a2 + 0x160);
        eax104 = fun_10002416(ecx, v103, v102, v101, v100, v99, v98, esi17, ebp18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10);
    }
    return eax104;
}

void** fun_10003447(int32_t ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8) {
    void** eax9;
    void** esi10;
    void** esi11;
    void** edi12;
    void** ebp13;

    if (!a3 || !a2) {
        eax9 = reinterpret_cast<void**>(0);
    } else {
        esi10 = *reinterpret_cast<void***>(a2);
        if (esi10 != a3 && ((*reinterpret_cast<void***>(a2) = a3, fun_100031d4(ecx, a3), !!esi10) && ((fun_10003263(a3, esi10), !*reinterpret_cast<void***>(esi10)) && esi10 != 0x1000d860))) {
            fun_100032fc(esi10, esi10, esi11, edi12, ebp13, __return_address(), a2, a3, a4, a5, a6, a7, a8);
        }
        eax9 = a3;
    }
    return eax9;
}

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

void fun_1000363b(void** ecx) {
    fun_10006d18(ecx, 12);
    return;
}

void fun_100045b5(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
    int32_t ebp7;
    int32_t* esp8;
    void* ebp9;

    g0 = *reinterpret_cast<void***>(ebp7 - 16);
    esp8 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(ebp9) + 4 - 4);
    *esp8 = reinterpret_cast<int32_t>(__return_address());
    goto *esp8;
}

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

void fun_100037f1(void** ecx);

void fun_100037fd(void** ecx);

void fun_100036d7(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15) {
    void** esi16;
    struct s46* ebp17;
    void** v18;
    void** v19;
    void** v20;
    void** v21;
    void** v22;
    void** v23;
    void** v24;
    void** v25;
    void** ecx26;
    int32_t ebp27;
    void** edi28;
    int32_t eax29;
    int32_t ebp30;
    void** ecx31;
    int32_t ebp32;
    void** edi33;
    int1_t zf34;
    int32_t ebp35;

    fun_10004570(0x1000c448, 8, __return_address());
    esi16 = ebp17->f8;
    if (esi16) {
        if (*reinterpret_cast<void***>(esi16 + 36)) {
            v18 = *reinterpret_cast<void***>(esi16 + 36);
            fun_10002416(ecx, v18, 0x1000c448, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v18;
        }
        if (*reinterpret_cast<void***>(esi16 + 44)) {
            v19 = *reinterpret_cast<void***>(esi16 + 44);
            fun_10002416(ecx, v19, 0x1000c448, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v19;
        }
        if (*reinterpret_cast<void***>(esi16 + 52)) {
            v20 = *reinterpret_cast<void***>(esi16 + 52);
            fun_10002416(ecx, v20, 0x1000c448, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v20;
        }
        if (*reinterpret_cast<void***>(esi16 + 60)) {
            v21 = *reinterpret_cast<void***>(esi16 + 60);
            fun_10002416(ecx, v21, 0x1000c448, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v21;
        }
        if (*reinterpret_cast<void***>(esi16 + 64)) {
            v22 = *reinterpret_cast<void***>(esi16 + 64);
            fun_10002416(ecx, v22, 0x1000c448, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v22;
        }
        if (*reinterpret_cast<void***>(esi16 + 68)) {
            v23 = *reinterpret_cast<void***>(esi16 + 68);
            fun_10002416(ecx, v23, 0x1000c448, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v23;
        }
        if (*reinterpret_cast<void***>(esi16 + 72)) {
            v24 = *reinterpret_cast<void***>(esi16 + 72);
            fun_10002416(ecx, v24, 0x1000c448, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v24;
        }
        if (*reinterpret_cast<void***>(esi16 + 92) != 0x1000a5f8) {
            v25 = *reinterpret_cast<void***>(esi16 + 92);
            fun_10002416(ecx, v25, 0x1000c448, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
            ecx = v25;
        }
        fun_10006df1(ecx, 13, 0x1000c448, 8, __return_address(), a2, a3, a4, a5, a6, a7);
        ecx26 = reinterpret_cast<void**>(13);
        *reinterpret_cast<uint32_t*>(ebp27 - 4) = 0;
        edi28 = *reinterpret_cast<void***>(esi16 + 0x68);
        if (edi28 && ((eax29 = reinterpret_cast<int32_t>(InterlockedDecrement(13, edi28)), !eax29) && edi28 != 0x1000d1d0)) {
            fun_10002416(13, edi28, edi28, 0x1000c448, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
            ecx26 = edi28;
        }
        *reinterpret_cast<int32_t*>(ebp30 - 4) = -2;
        fun_100037f1(ecx26);
        fun_10006df1(ecx26, 12, 0x1000c448, 8, __return_address(), a2, a3, a4, a5, a6, a7);
        ecx31 = reinterpret_cast<void**>(12);
        *reinterpret_cast<int32_t*>(ebp32 - 4) = 1;
        edi33 = *reinterpret_cast<void***>(esi16 + 0x6c);
        if (edi33 && ((fun_10003263(12, edi33), ecx31 = edi33, zf34 = edi33 == image_base_, !zf34) && (edi33 != 0x1000d860 && !*reinterpret_cast<void***>(edi33)))) {
            fun_100032fc(ecx31, edi33, 0x1000c448, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
            ecx31 = edi33;
        }
        *reinterpret_cast<int32_t*>(ebp35 - 4) = -2;
        fun_100037fd(ecx31);
        fun_10002416(ecx31, esi16, 0x1000c448, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
        ecx = esi16;
    }
    fun_100045b5(ecx, 0x1000c448, 8, __return_address(), a2, a3);
    goto 0x1000c448;
}

int32_t GetProcAddress = 0xcaae;

void** g1000e18c;

void fun_10003516();

int32_t TlsAlloc = 0xca58;

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

int32_t EncodePointer = 0xc9e4;

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

int32_t fun_10003874(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13) {
    void** eax14;
    void** edi15;
    int32_t esi16;
    void** esi17;
    void** eax18;
    void** eax19;
    void** eax20;
    void** eax21;
    int1_t zf22;
    void** esi23;
    int1_t zf24;
    int1_t zf25;
    void** eax26;
    void** eax27;
    void** eax28;
    void** v29;
    int32_t eax30;
    void** v31;
    int32_t esi32;
    void** eax33;
    void** v34;
    void** eax35;
    void** v36;
    void** eax37;
    void** v38;
    void** eax39;
    int32_t eax40;
    int32_t edi41;
    void** v42;
    int32_t eax43;
    void** eax44;
    void** eax45;
    void** v46;
    void** v47;
    int32_t eax48;
    int32_t eax49;
    void** eax50;

    eax14 = reinterpret_cast<void**>(GetModuleHandleW());
    if (!eax14) {
        fun_10003553(ecx, "K", edi15, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
        goto edi15;
    }
    esi16 = GetProcAddress;
    eax18 = reinterpret_cast<void**>(esi16(eax14, "FlsAlloc", esi17));
    g1000e18c = eax18;
    eax19 = reinterpret_cast<void**>(esi16(eax14, "FlsGetValue", eax14, "FlsAlloc", esi17));
    g1000e190 = eax19;
    eax20 = reinterpret_cast<void**>(esi16());
    g1000e194 = eax20;
    eax21 = reinterpret_cast<void**>(esi16());
    zf22 = g1000e18c == 0;
    esi23 = TlsSetValue;
    g1000e198 = eax21;
    if (zf22 || ((zf24 = g1000e190 == 0, zf24) || ((zf25 = g1000e194 == 0, zf25) || !eax21))) {
        eax26 = TlsGetValue;
        g1000e190 = eax26;
        eax27 = TlsFree;
        g1000e18c = reinterpret_cast<void**>(fun_10003516);
        g1000e194 = esi23;
        g1000e198 = eax27;
    }
    eax28 = reinterpret_cast<void**>(TlsAlloc());
    g1000d940 = eax28;
    if (eax28 == 0xffffffff) 
        goto addr_100039ea_6;
    v29 = g1000e190;
    eax30 = reinterpret_cast<int32_t>(esi23(eax28, v29));
    if (eax30) 
        goto addr_1000393a_8;
    addr_100039ea_6:
    addr_100039ec_9:
    goto eax14;
    addr_1000393a_8:
    fun_10003c1c(ecx, eax28, v29, eax14, "FlsFree");
    v31 = g1000e18c;
    esi32 = EncodePointer;
    eax33 = reinterpret_cast<void**>(esi32(v31, eax28, v29));
    v34 = g1000e190;
    g1000e18c = eax33;
    eax35 = reinterpret_cast<void**>(esi32(v34, v31, eax28, v29));
    v36 = g1000e194;
    g1000e190 = eax35;
    eax37 = reinterpret_cast<void**>(esi32(v36, v34, v31, eax28, v29));
    v38 = g1000e198;
    g1000e194 = eax37;
    eax39 = reinterpret_cast<void**>(esi32(v38, v36, v34, v31, eax28, v29));
    g1000e198 = eax39;
    eax40 = fun_10006c77(v38, v36, v34, v31, eax28, v29);
    if (!eax40 || ((edi41 = DecodePointer, v42 = g1000e18c, eax43 = reinterpret_cast<int32_t>(edi41(v42, fun_100036d7, v38, v36, v34, v31, eax28, v29)), eax44 = reinterpret_cast<void**>(eax43(v42, fun_100036d7, v38, v36, v34, v31, eax28, v29)), g1000d93c = eax44, eax44 == 0xffffffff) || ((eax45 = fun_10003b2d(ecx, 1, 0x214, v42, fun_100036d7, v38, v36, v34, v31, eax28, v29), ecx = reinterpret_cast<void**>(0x214), eax45 == 0) || (v46 = g1000d93c, v47 = g1000e194, eax48 = reinterpret_cast<int32_t>(edi41(0x214, v47, v46, eax45, v42, fun_100036d7, v38, v36, v34, v31, eax28, v29)), eax49 = reinterpret_cast<int32_t>(eax48(0x214, v47, v46, eax45, v42, fun_100036d7, v38, v36, v34, v31, eax28, v29)), eax49 == 0)))) {
        fun_10003553(ecx, v38, v36, v34, v31, eax28, v29, eax14, "FlsFree", eax14, "FlsSetValue", eax14, "FlsGetValue", eax14, "FlsAlloc", esi17);
        goto addr_100039ea_6;
    } else {
        fun_10003590(0x214, eax45, 0, v47, v46, eax45, v42, fun_100036d7, v38, v36, v34, v31, eax28, v29);
        eax50 = reinterpret_cast<void**>(GetCurrentThreadId(0, v47, v46, eax45, v42, fun_100036d7, v38, v36, v34, v31, eax28, v29));
        *reinterpret_cast<void***>(eax45 + 4) = reinterpret_cast<void**>(0xffffffff);
        *reinterpret_cast<void***>(eax45) = eax50;
        goto addr_100039ec_9;
    }
}

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

void fun_10004c4c(void** a1);

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

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

void fun_10007840(void** a1, void** a2, void** a3, void** a4);

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

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

void fun_10003c1c(void** ecx, void** a2, void** a3, void** a4, void** a5) {
    void** esi6;
    void** eax7;

    eax7 = fun_1000350d(ecx, esi6, __return_address(), a2, a3, a4, a5);
    fun_10004c4c(eax7);
    fun_100026ba(eax7, eax7);
    fun_1000784f(eax7, eax7, eax7);
    fun_10007840(eax7, eax7, eax7, eax7);
    fun_1000763b(eax7, eax7, eax7, eax7, eax7);
    fun_1000762a(eax7, eax7, eax7, eax7, eax7, eax7);
    return;
}

int32_t fun_10006c77(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6) {
    int32_t esi7;
    int32_t edi8;
    int32_t* eax9;
    int32_t v10;
    int32_t eax11;
    int32_t eax12;

    esi7 = 0;
    edi8 = 0x1000e2f8;
    do {
        if (*reinterpret_cast<int32_t*>(esi7 * 8 + 0x1000dc44) != 1) 
            continue;
        eax9 = reinterpret_cast<int32_t*>(esi7 * 8 + 0x1000dc40);
        *eax9 = edi8;
        v10 = *eax9;
        edi8 = edi8 + 24;
        eax11 = reinterpret_cast<int32_t>(InitializeCriticalSectionAndSpinCount(v10, 0xfa0));
        if (!eax11) 
            break;
        ++esi7;
    } while (esi7 < 36);
    goto addr_10006caf_5;
    *reinterpret_cast<uint32_t*>(esi7 * 8 + 0x1000dc40) = 0;
    eax12 = 0;
    addr_10006cb2_7:
    return eax12;
    addr_10006caf_5:
    eax12 = 1;
    goto addr_10006cb2_7;
}

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

void** fun_10003b79(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11) {
    void** v12;
    void** v13;
    void** ebp14;
    void** v15;
    void** esi16;
    void** v17;
    void** edi18;
    void** esi19;
    void** eax20;
    int1_t below_or_equal21;
    void** eax22;
    int1_t below_or_equal23;

    v12 = reinterpret_cast<void**>(__return_address());
    v13 = ebp14;
    v15 = esi16;
    v17 = edi18;
    esi19 = reinterpret_cast<void**>(0);
    do {
        eax20 = fun_10007544(ecx, a2, a3, v17, v15, v13, v12, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
        ecx = a3;
        if (eax20) 
            break;
        if (a3 == eax20) 
            break;
        below_or_equal21 = reinterpret_cast<unsigned char>(g1000e1a4) <= reinterpret_cast<unsigned char>(eax20);
        if (below_or_equal21) 
            break;
        Sleep(ecx, esi19);
        eax22 = esi19 + 0x3e8;
        below_or_equal23 = reinterpret_cast<unsigned char>(eax22) <= reinterpret_cast<unsigned char>(g1000e1a4);
        if (!below_or_equal23) {
            eax22 = reinterpret_cast<void**>(0xffffffff);
        }
        esi19 = eax22;
    } while (!reinterpret_cast<int1_t>(eax22 == 0xffffffff));
    return eax20;
}

void fun_10003bc7(void** a1, void** a2, void** a3) {
    int32_t eax4;
    int32_t eax5;
    int32_t ebp6;

    eax4 = reinterpret_cast<int32_t>(GetModuleHandleW());
    if (eax4 && (eax5 = reinterpret_cast<int32_t>(GetProcAddress(eax4, "CorExitProcess")), !!eax5)) {
        eax5(a1, eax4, "CorExitProcess");
    }
    goto ebp6;
}

struct s47 {
    int16_t f0;
    signed char[58] pad60;
    int32_t f60;
};

int32_t fun_10007860(struct s47* a1);

struct s48 {
    signed char[8] pad8;
    int32_t f8;
    uint32_t f12;
    signed char[20] pad36;
    uint32_t f36;
};

struct s49 {
    signed char[60] pad60;
    int32_t f60;
};

struct s48* fun_100078a0(struct s49* a1, uint32_t a2);

uint32_t fun_100078f0(void** ecx, void** a2) {
    void** eax3;
    int32_t eax4;
    struct s48* eax5;
    uint32_t eax6;

    eax3 = g0;
    g0 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 + 0xfffffff0);
    eax4 = fun_10007860(0x10000000);
    if (!eax4 || (eax5 = fun_100078a0(0x10000000, a2 - 0x10000000), eax5 == 0)) {
        g0 = eax3;
        return 0;
    } else {
        eax6 = ~(eax5->f36 >> 31) & 1;
        g0 = eax3;
        return eax6;
    }
}

void** fun_1000350d(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
    EncodePointer();
    goto 0;
}

int32_t LeaveCriticalSection = 0xcc86;

void fun_10006d18(void** ecx, void** a2) {
    int32_t ebp3;

    LeaveCriticalSection();
    goto ebp3;
}

int32_t ExitProcess = 0xcac0;

void fun_10003bf2(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
    void** ebp8;

    fun_10003bc7(a2, ebp8, __return_address());
    ExitProcess(a2);
    fun_10006df1(a2, 8, a2, ebp8, __return_address(), a2, a3, a4, a5, a6, a7);
    goto a2;
}

void** fun_100031b6(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13) {
    int1_t zf14;

    zf14 = g1000fc4c == 0;
    if (zf14) {
        fun_1000301c(ecx, 0xfd, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
        g1000fc4c = reinterpret_cast<void**>(1);
    }
    return 0;
}

void** fun_100058d0(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, ...) {
    void** ecx7;
    void* eax8;

    ecx7 = a1;
    if (!(reinterpret_cast<unsigned char>(ecx7) & 3)) {
        while (1) {
            addr_10005900_2:
            ecx7 = ecx7 + 4;
            if (!((reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(ecx7)) ^ 0xffffffff ^ reinterpret_cast<uint32_t>(*reinterpret_cast<void***>(ecx7) + 0x7efefeff)) & 0x81010100)) 
                continue;
            eax8 = *reinterpret_cast<void**>(ecx7 + 0xfffffffc);
            if (!*reinterpret_cast<signed char*>(&eax8)) 
                break;
            if (!*reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(&eax8) + 1)) 
                goto addr_10005947_5;
            if (!(reinterpret_cast<uint32_t>(eax8) & 0xff0000)) 
                goto addr_1000593d_7;
            if (!(reinterpret_cast<uint32_t>(eax8) & 0xff000000)) 
                goto addr_10005933_9;
        }
    } else {
        do {
            ++ecx7;
            if (!*reinterpret_cast<void***>(ecx7)) 
                goto addr_10005933_9;
        } while (reinterpret_cast<unsigned char>(ecx7) & 3);
        goto addr_100058ed_13;
    }
    return reinterpret_cast<uint32_t>(ecx7 + 0xfffffffc) - reinterpret_cast<unsigned char>(a1);
    addr_10005947_5:
    return reinterpret_cast<uint32_t>(ecx7 + 0xfffffffd) - reinterpret_cast<unsigned char>(a1);
    addr_1000593d_7:
    return reinterpret_cast<uint32_t>(ecx7 + 0xfffffffe) - reinterpret_cast<unsigned char>(a1);
    addr_10005933_9:
    return reinterpret_cast<unsigned char>(ecx7 + 0xffffffff) - reinterpret_cast<unsigned char>(a1);
    addr_100058ed_13:
    goto addr_10005900_2;
}

void** fun_10007302(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
    void** v8;
    void** v9;
    void** ebp10;
    void** edx11;
    void** v12;
    void** esi13;
    void** v14;
    void** edi15;
    void** edi16;
    void** eax17;
    void** esi18;
    void** eax19;
    void* esi20;
    void** eax21;
    void** eax22;

    v8 = reinterpret_cast<void**>(__return_address());
    v9 = ebp10;
    edx11 = a2;
    v12 = esi13;
    v14 = edi15;
    if (!edx11 || (edi16 = a3, !edi16)) {
        addr_10007317_2:
        eax17 = fun_10002896(ecx, v14, v12, v9, v8, a2, a3, a4, a5, a6, a7);
        esi18 = reinterpret_cast<void**>(22);
        *reinterpret_cast<void***>(eax17) = reinterpret_cast<void**>(22);
    } else {
        eax19 = a4;
        if (eax19) {
            esi20 = reinterpret_cast<void*>(reinterpret_cast<unsigned char>(edx11) - reinterpret_cast<unsigned char>(eax19));
            do {
                ecx = *reinterpret_cast<void***>(eax19);
                *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(esi20) + reinterpret_cast<unsigned char>(eax19)) = ecx;
                ++eax19;
                if (!ecx) 
                    break;
                --edi16;
            } while (edi16);
            if (edi16) 
                goto addr_1000735b_8; else 
                goto addr_1000734a_9;
        } else {
            *reinterpret_cast<void***>(edx11) = eax19;
            goto addr_10007317_2;
        }
    }
    addr_10007321_11:
    fun_10002844(ecx);
    eax21 = esi18;
    addr_1000735d_12:
    return eax21;
    addr_1000735b_8:
    eax21 = reinterpret_cast<void**>(0);
    goto addr_1000735d_12;
    addr_1000734a_9:
    *reinterpret_cast<void***>(edx11) = reinterpret_cast<void**>(0);
    eax22 = fun_10002896(ecx, v14, v12, v9, v8, a2, a3, a4, a5, a6, a7);
    ecx = reinterpret_cast<void**>(34);
    *reinterpret_cast<void***>(eax22) = reinterpret_cast<void**>(34);
    esi18 = reinterpret_cast<void**>(34);
    goto addr_10007321_11;
}

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

uint32_t fun_10007c0d(void** a1) {
    uint32_t eax2;

    eax2 = fun_10007bba(0, a1, 0, 4);
    return eax2;
}

void** g1000e2e4;

int32_t GetModuleFileNameA = 0xcb50;

void** g1000e1c8;

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

int32_t g1000e1ac;

void** g1000e1b0;

uint32_t fun_1000439b(void** ecx, void** a2, void** a3, void** a4, void** a5) {
    void*** ebp6;
    int1_t zf7;
    void** edi8;
    void** esi9;
    void** ebx10;
    void** v11;
    void** v12;
    void** v13;
    void** ebp14;
    void** eax15;
    void** v16;
    void** v17;
    void** v18;
    void* edi19;
    void** eax20;
    void** v21;
    void** v22;
    void** v23;
    uint32_t eax24;
    int32_t v25;

    ebp6 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    zf7 = g1000fc4c == 0;
    if (zf7) {
        fun_100031b6(ecx, edi8, esi9, ebx10, v11, v12, v13, ebp14, __return_address(), a2, a3, a4, a5);
    }
    g1000e2e4 = reinterpret_cast<void**>(0);
    GetModuleFileNameA();
    eax15 = g1000fc58;
    g1000e1c8 = reinterpret_cast<void**>(0x1000e1e0);
    if (!eax15 || (v16 = eax15, !*reinterpret_cast<void***>(eax15))) {
        v16 = reinterpret_cast<void**>(0x1000e1e0);
    }
    fun_10004201(ecx, 0, 0, ebp6 - 8);
    if (reinterpret_cast<unsigned char>(v17) >= reinterpret_cast<unsigned char>(0x3fffffff) || (reinterpret_cast<unsigned char>(v18) >= reinterpret_cast<unsigned char>(0xffffffff) || ((edi19 = reinterpret_cast<void*>(reinterpret_cast<unsigned char>(v17) << 2), eax20 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(edi19) + reinterpret_cast<unsigned char>(v18)), reinterpret_cast<unsigned char>(eax20) < reinterpret_cast<unsigned char>(v18)) || (v21 = eax20, eax20 = fun_10003ae8(v18, v21, 0, 0x1000e1e0, 0x104, edi8, esi9, ebx10, v22, v23, v16, ebp14, __return_address(), a2, a3), eax20 == 0)))) {
        eax24 = 0xffffffff;
    } else {
        fun_10004201(v21, eax20, reinterpret_cast<uint32_t>(edi19) + reinterpret_cast<unsigned char>(eax20), ebp6 - 8);
        g1000e1ac = v25 - 1;
        g1000e1b0 = eax20;
        eax24 = 0;
    }
    return eax24;
}

void fun_10004201(void** ecx, void** a2, void** a3, int32_t* a4) {
    void*** edi5;
    void*** edi6;
    int32_t* ecx7;
    void*** esi8;
    void*** edx9;
    void** edx10;
    void** ebx11;
    void** v12;
    void** bl13;
    uint32_t eax14;
    void** ecx15;
    void** al16;
    void** eax17;
    uint32_t v18;
    void** eax19;
    int32_t ebx20;
    uint32_t ecx21;
    void*** eax22;
    uint32_t eax23;
    void** v24;
    uint32_t eax25;
    uint32_t eax26;
    void** al27;
    void** ecx28;
    void** ecx29;
    void** al30;

    edi5 = edi6;
    ecx7 = a4;
    *edi5 = reinterpret_cast<void**>(0);
    esi8 = edx9;
    edx10 = a3;
    *ecx7 = 1;
    if (a2) {
        ebx11 = a2;
        a2 = a2 + 4;
        *reinterpret_cast<void***>(ebx11) = edx10;
    }
    v12 = reinterpret_cast<void**>(0);
    do {
        if (!reinterpret_cast<int1_t>(*esi8 == 34)) {
            *edi5 = *edi5 + 1;
            if (edx10) {
                *reinterpret_cast<void***>(edx10) = *esi8;
                a3 = edx10 + 1;
            }
            bl13 = *esi8;
            ++esi8;
            eax14 = fun_10007c0d(static_cast<uint32_t>(reinterpret_cast<unsigned char>(bl13)));
            if (eax14) {
                *edi5 = *edi5 + 1;
                if (a3) {
                    ecx15 = a3;
                    al16 = *esi8;
                    ++a3;
                    *reinterpret_cast<void***>(ecx15) = al16;
                }
                ++esi8;
            }
            edx10 = a3;
            ecx7 = a4;
            if (!bl13) 
                break;
        } else {
            eax17 = reinterpret_cast<void**>(0);
            bl13 = reinterpret_cast<void**>(34);
            *reinterpret_cast<unsigned char*>(&eax17) = reinterpret_cast<uint1_t>(v12 == 0);
            ++esi8;
            v12 = eax17;
        }
    } while (v12 || bl13 != 32 && !reinterpret_cast<int1_t>(bl13 == 9));
    goto addr_1000428d_14;
    --esi8;
    addr_10004295_16:
    v18 = 0;
    while (*esi8) {
        while (*esi8 == 32 || reinterpret_cast<int1_t>(*esi8 == 9)) {
            ++esi8;
        }
        if (!*esi8) 
            break;
        if (a2) {
            eax19 = a2;
            a2 = a2 + 4;
            *reinterpret_cast<void***>(eax19) = edx10;
        }
        *ecx7 = *ecx7 + 1;
        while (1) {
            ebx20 = 1;
            ecx21 = 0;
            while (*esi8 == 92) {
                ++esi8;
                ++ecx21;
            }
            if (reinterpret_cast<int1_t>(*esi8 == 34)) {
                if (!(*reinterpret_cast<unsigned char*>(&ecx21) & 1)) {
                    if (!v18 || (eax22 = esi8 + 1, !reinterpret_cast<int1_t>(*eax22 == 34))) {
                        eax23 = 0;
                        ebx20 = 0;
                        *reinterpret_cast<unsigned char*>(&eax23) = reinterpret_cast<uint1_t>(v18 == 0);
                        v18 = eax23;
                    } else {
                        esi8 = eax22;
                    }
                }
                ecx21 = ecx21 >> 1;
            }
            if (ecx21) {
                do {
                    --ecx21;
                    if (edx10) {
                        *reinterpret_cast<void***>(edx10) = reinterpret_cast<void**>(92);
                        ++edx10;
                    }
                    *edi5 = *edi5 + 1;
                } while (ecx21);
                a3 = edx10;
            }
            if (!*esi8) 
                break;
            if (v18) 
                goto addr_1000432f_40;
            if (*esi8 == 32) 
                break;
            if (*esi8 == 9) 
                break;
            addr_1000432f_40:
            if (ebx20) {
                v24 = reinterpret_cast<void**>(static_cast<int32_t>(reinterpret_cast<signed char>(*esi8)));
                if (!edx10) {
                    eax25 = fun_10007c0d(v24);
                    if (eax25) {
                        ++esi8;
                        *edi5 = *edi5 + 1;
                    }
                } else {
                    eax26 = fun_10007c0d(v24);
                    if (eax26) {
                        al27 = *esi8;
                        ecx28 = a3;
                        ++a3;
                        *reinterpret_cast<void***>(ecx28) = al27;
                        ++esi8;
                        *edi5 = *edi5 + 1;
                    }
                    ecx29 = a3;
                    al30 = *esi8;
                    ++a3;
                    *reinterpret_cast<void***>(ecx29) = al30;
                }
                *edi5 = *edi5 + 1;
                edx10 = a3;
            }
            ++esi8;
        }
        if (edx10) {
            *reinterpret_cast<void***>(edx10) = reinterpret_cast<void**>(0);
            ++edx10;
            a3 = edx10;
        }
        *edi5 = *edi5 + 1;
        ecx7 = a4;
    }
    if (a2) {
        *reinterpret_cast<void***>(a2) = reinterpret_cast<void**>(0);
    }
    *ecx7 = *ecx7 + 1;
    return;
    addr_1000428d_14:
    if (edx10) {
        *reinterpret_cast<void***>(edx10 + 0xffffffff) = reinterpret_cast<void**>(0);
        goto addr_10004295_16;
    }
}

int32_t fun_10007462(int32_t ecx) {
    int32_t eax2;

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

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

void fun_100074ab(void** ecx, void** a2, int32_t a3) {
    void** edx4;

    fun_10007370(a2, ecx, edx4);
    return;
}

void** fun_1000475f(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8) {
    void** esi9;
    void** ebp10;
    void** eax11;
    void** esi12;
    void** ecx13;
    void** edx14;
    void** eax15;
    void** edx16;
    void** ebx17;
    void* ecx18;
    void** edi19;

    eax11 = fun_10003644(ecx, esi9, ebp10, __return_address(), a2, a3, a4, a5, a6, a7, a8);
    esi12 = eax11;
    if (!esi12) {
        addr_100048a6_2:
        return eax11;
    } else {
        ecx13 = *reinterpret_cast<void***>(esi12 + 92);
        edx14 = a2;
        eax15 = ecx13;
        do {
            if (*reinterpret_cast<void***>(eax15) == edx14) 
                break;
            eax15 = eax15 + 12;
        } while (reinterpret_cast<unsigned char>(eax15) < reinterpret_cast<unsigned char>(ecx13 + 0x90));
        if (reinterpret_cast<unsigned char>(eax15) >= reinterpret_cast<unsigned char>(ecx13 + 0x90)) 
            goto addr_1000479c_7;
        if (*reinterpret_cast<void***>(eax15) == edx14) 
            goto addr_1000479e_9;
    }
    addr_1000479c_7:
    eax15 = reinterpret_cast<void**>(0);
    addr_1000479e_9:
    if (!eax15 || (edx16 = *reinterpret_cast<void***>(eax15 + 8), !edx16)) {
        eax11 = reinterpret_cast<void**>(0);
    } else {
        if (!reinterpret_cast<int1_t>(edx16 == 5)) {
            if (edx16 == 1) {
                addr_100048a2_13:
                eax11 = reinterpret_cast<void**>(0xffffffff);
            } else {
                ebx17 = *reinterpret_cast<void***>(esi12 + 96);
                *reinterpret_cast<void***>(esi12 + 96) = a3;
                if (!reinterpret_cast<int1_t>(*reinterpret_cast<void***>(eax15 + 4) == 8)) {
                    *reinterpret_cast<void***>(eax15 + 8) = reinterpret_cast<void**>(0);
                    edx16();
                    goto addr_1000489d_16;
                } else {
                    ecx18 = reinterpret_cast<void*>(36);
                    do {
                        *reinterpret_cast<uint32_t*>(reinterpret_cast<int32_t>(ecx18) + reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(esi12 + 92)) + 8) = 0;
                        ecx18 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(ecx18) + 12);
                    } while (reinterpret_cast<int32_t>(ecx18) < 0x90);
                    edi19 = *reinterpret_cast<void***>(esi12 + 100);
                    if (!reinterpret_cast<int1_t>(*reinterpret_cast<void***>(eax15) == 0xc000008e)) 
                        goto addr_1000480b_20; else 
                        goto addr_10004802_21;
                }
            }
        } else {
            *reinterpret_cast<void***>(eax15 + 8) = reinterpret_cast<void**>(0);
            eax11 = reinterpret_cast<void**>(1);
        }
    }
    goto addr_100048a6_2;
    addr_1000489d_16:
    *reinterpret_cast<void***>(esi12 + 96) = ebx17;
    goto addr_100048a2_13;
    addr_1000480b_20:
    if (!reinterpret_cast<int1_t>(*reinterpret_cast<void***>(eax15) == 0xc0000090)) {
        if (!reinterpret_cast<int1_t>(*reinterpret_cast<void***>(eax15) == 0xc0000091)) {
            if (!reinterpret_cast<int1_t>(*reinterpret_cast<void***>(eax15) == 0xc0000093)) {
                if (!reinterpret_cast<int1_t>(*reinterpret_cast<void***>(eax15) == 0xc000008d)) {
                    if (!reinterpret_cast<int1_t>(*reinterpret_cast<void***>(eax15) == 0xc000008f)) {
                        if (!reinterpret_cast<int1_t>(*reinterpret_cast<void***>(eax15) == 0xc0000092)) {
                            if (!reinterpret_cast<int1_t>(*reinterpret_cast<void***>(eax15) == 0xc00002b5)) {
                                if (reinterpret_cast<int1_t>(*reinterpret_cast<void***>(eax15) == 0xc00002b4)) {
                                    *reinterpret_cast<void***>(esi12 + 100) = reinterpret_cast<void**>(0x8e);
                                }
                            } else {
                                *reinterpret_cast<void***>(esi12 + 100) = reinterpret_cast<void**>(0x8d);
                            }
                        } else {
                            *reinterpret_cast<void***>(esi12 + 100) = reinterpret_cast<void**>(0x8a);
                        }
                    } else {
                        *reinterpret_cast<void***>(esi12 + 100) = reinterpret_cast<void**>(0x86);
                    }
                } else {
                    *reinterpret_cast<void***>(esi12 + 100) = reinterpret_cast<void**>(0x82);
                }
            } else {
                *reinterpret_cast<void***>(esi12 + 100) = reinterpret_cast<void**>(0x85);
            }
        } else {
            *reinterpret_cast<void***>(esi12 + 100) = reinterpret_cast<void**>(0x84);
        }
    } else {
        *reinterpret_cast<void***>(esi12 + 100) = reinterpret_cast<void**>(0x81);
    }
    addr_10004889_39:
    edx16();
    *reinterpret_cast<void***>(esi12 + 100) = edi19;
    goto addr_1000489d_16;
    addr_10004802_21:
    *reinterpret_cast<void***>(esi12 + 100) = reinterpret_cast<void**>(0x83);
    goto addr_10004889_39;
}

void** fun_10004994(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14) {
    void** esi15;
    void** edi16;
    void** ebp17;
    void** eax18;
    void** esi19;
    void** eax20;

    if (a2) {
        eax18 = fun_100058d0(a2, esi15, edi16, ebp17, __return_address(), a2);
        esi19 = eax18 + 1;
        eax20 = fun_10004bb8(ecx, esi19, a2, esi15, edi16, ebp17, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
        *reinterpret_cast<void***>(ecx + 4) = eax20;
        if (eax20) {
            eax20 = fun_10007302(a2, eax20, esi19, a2, esi15, edi16, ebp17);
            *reinterpret_cast<void***>(ecx + 8) = reinterpret_cast<void**>(1);
        }
    }
    return eax20;
}

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

void** fun_100049f2(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12) {
    void** edi13;
    void** esi14;
    void** ebp15;
    void** v16;

    if (ecx != a2) {
        fun_100049d4(ecx, edi13, esi14, ebp15, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12);
        if (!*reinterpret_cast<void***>(a2 + 8)) {
            *reinterpret_cast<void***>(ecx + 4) = *reinterpret_cast<void***>(a2 + 4);
        } else {
            v16 = *reinterpret_cast<void***>(a2 + 4);
            fun_10004994(ecx, v16, edi13, esi14, ebp15, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
        }
    }
    return ecx;
}

void** fun_100049d4(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void** a16) {
    void** v17;
    void** esi18;
    void** eax19;

    if (*reinterpret_cast<void***>(ecx + 8)) {
        v17 = *reinterpret_cast<void***>(ecx + 4);
        eax19 = fun_10002416(ecx, v17, esi18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16);
    }
    *reinterpret_cast<void***>(ecx + 4) = reinterpret_cast<void**>(0);
    *reinterpret_cast<void***>(ecx + 8) = reinterpret_cast<void**>(0);
    return eax19;
}

int32_t HeapSize = 0xcd16;

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

    if (a2) {
        HeapSize();
        goto 0;
    } else {
        eax11 = fun_10002896(ecx, ebp10, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
        *reinterpret_cast<void***>(eax11) = reinterpret_cast<void**>(22);
        fun_10002844(ecx);
        return 0xffffffff;
    }
}

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

int32_t g1000de30 = 0;

void** fun_10007b81(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
    void** eax8;
    void** eax9;
    int1_t zf10;

    eax8 = fun_10008add(ecx, 3, __return_address(), a2, a3, a4, a5, a6, a7);
    if (eax8 == 1 || (eax9 = fun_10008add(3, 3, __return_address(), a2, a3, a4, a5, a6, a7), !eax9) && (zf10 = g1000de30 == 1, zf10)) {
        fun_100079d2(3, 0xfc, __return_address(), a2, a3);
        eax9 = fun_100079d2(3, 0xff, 0xfc, __return_address(), a2);
    }
    return eax9;
}

void** fun_100079ac(void** a1);

int32_t WriteFile = 0xcc40;

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

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

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

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

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

int16_t g1000e6ea;

int32_t GetModuleFileNameW = 0xcd00;

void** fun_100079d2(void** ecx, void** a2, void** a3, void** a4, void** a5) {
    void* ebp6;
    void** eax7;
    uint32_t v8;
    void** v9;
    void** esi10;
    void** esi11;
    void** v12;
    void** edi13;
    void** eax14;
    void** edi15;
    void** ebx16;
    void** v17;
    void** ebx18;
    void** v19;
    void** v20;
    void** v21;
    void** eax22;
    void** v23;
    void** v24;
    void** v25;
    void** eax26;
    void** ecx27;
    int1_t zf28;
    void** eax29;
    void** esi30;
    void* eax31;
    void** v32;
    void** v33;
    void** eax34;
    void** eax35;
    void** v36;
    void** v37;
    int32_t eax38;
    int32_t eax39;
    void** eax40;
    void** eax41;
    void** eax42;
    void** eax43;
    int32_t eax44;
    void** eax45;
    void** eax46;

    ebp6 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    eax7 = g1000d050;
    v8 = reinterpret_cast<unsigned char>(eax7) ^ reinterpret_cast<uint32_t>(ebp6);
    v9 = esi10;
    esi11 = a2;
    v12 = edi13;
    eax14 = fun_100079ac(esi11);
    edi15 = eax14;
    ebx16 = reinterpret_cast<void**>(0);
    v17 = edi15;
    if (edi15) {
        eax22 = fun_10008add(esi11, 3, v12, v9, ebx18, v17, v19, v20, v21);
        if (eax22 == 1 || (eax26 = fun_10008add(3, 3, v12, v9, ebx18, v17, v23, v24, v25), ecx27 = reinterpret_cast<void**>(3), !eax26) && (zf28 = g1000de30 == 1, zf28)) {
            eax29 = reinterpret_cast<void**>(GetStdHandle(3, 0xf4));
            esi30 = eax29;
            if (esi30 && esi30 != 0xffffffff) {
                eax31 = reinterpret_cast<void*>(0);
                do {
                    *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(ebp6) + reinterpret_cast<uint32_t>(eax31) - 0x1f8) = *reinterpret_cast<void***>(edi15 + reinterpret_cast<uint32_t>(eax31) * 2);
                    if (!*reinterpret_cast<void***>(edi15 + reinterpret_cast<uint32_t>(eax31) * 2)) 
                        break;
                    eax31 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(eax31) + 1);
                } while (reinterpret_cast<uint32_t>(eax31) < 0x1f4);
                v32 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp6) + 0xfffffe04);
                v33 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp6) + 0xfffffe08);
                eax34 = fun_100058d0(v33, v32, 0, 0xf4, v12, v9);
                WriteFile(v33, esi30, reinterpret_cast<uint32_t>(ebp6) + 0xfffffe08, eax34, v32, 0, 0xf4);
            }
        } else {
            if (esi11 != 0xfc) {
                eax35 = fun_10008a7a(3, 0x1000e4b0, 0x314, "R", v12, v9, ebx18);
                if (eax35) {
                    v36 = reinterpret_cast<void**>(0);
                    v37 = reinterpret_cast<void**>(0);
                    while (1) {
                        fun_100027f2(ecx27, 0, 0, 0, v37, v36);
                        addr_10007a9c_12:
                        eax38 = fun_10008a5f(ecx27, esi11, 0, v37, v36);
                        ecx27 = esi11;
                        if (eax38 + 1 <= 60) 
                            goto addr_10007ad3_13;
                        eax39 = fun_10008a5f(ecx27, esi11, 0, v37, v36);
                        eax40 = reinterpret_cast<void**>(eax39 * 2 + 0x1000e46c);
                        ecx27 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(reinterpret_cast<unsigned char>(eax40) - reinterpret_cast<unsigned char>(esi11)) >> 1);
                        ebx16 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ebx16) - reinterpret_cast<unsigned char>(ecx27));
                        eax41 = fun_10008992(eax40, ebx16, ".", 3, esi11, 0, v37, v36);
                        if (eax41) 
                            goto addr_10007a90_15;
                        addr_10007ad3_13:
                        esi11 = reinterpret_cast<void**>(0x314);
                        eax42 = fun_1000891d(ecx27, 0x1000e4b0, 0x314, "\n", 0, v37, v36);
                        if (eax42) 
                            goto addr_10007a90_15;
                        eax43 = fun_1000891d(ecx27, 0x1000e4b0, 0x314, v17, 0, v37, v36);
                        if (!eax43) 
                            break;
                        addr_10007a90_15:
                    }
                    fun_100087b1(ecx27, 0x1000e4b0, "M", 0x12010, 0, v37, v36);
                } else {
                    v36 = reinterpret_cast<void**>(0x104);
                    esi11 = reinterpret_cast<void**>(0x1000e4e2);
                    v37 = reinterpret_cast<void**>(0x1000e4e2);
                    g1000e6ea = *reinterpret_cast<int16_t*>(&eax35);
                    eax44 = reinterpret_cast<int32_t>(GetModuleFileNameW(3, 0, 0x1000e4e2, 0x104));
                    ebx16 = reinterpret_cast<void**>(0x2fb);
                    if (eax44) 
                        goto addr_10007a9c_12;
                    eax45 = fun_10008a7a(3, 0x1000e4e2, 0x2fb, "<", 0, 0x1000e4e2, 0x104);
                    if (!eax45) 
                        goto addr_10007a9c_12; else 
                        goto addr_10007a90_15;
                }
            }
        }
    }
    eax46 = fun_10001cc4(v8 ^ reinterpret_cast<uint32_t>(ebp6), v17);
    return eax46;
}

int32_t fun_10004c5b(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
    int32_t eax8;
    int32_t eax9;
    int32_t ebp10;

    eax8 = reinterpret_cast<int32_t>(DecodePointer());
    if (!eax8 || (eax9 = reinterpret_cast<int32_t>(eax8()), eax9 == 0)) {
        goto ebp10;
    } else {
        goto ebp10;
    }
}

void** fun_100028bc(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8) {
    void** esi9;
    void** ebp10;
    void** eax11;
    void** eax12;
    void** eax13;

    eax11 = fun_100028a9(ecx, esi9, ebp10, __return_address(), a2, a3, a4, a5, a6, a7);
    *reinterpret_cast<void***>(eax11) = a2;
    eax12 = fun_10002854(a2, a2, esi9, ebp10, __return_address(), a2);
    eax13 = fun_10002896(a2, esi9, ebp10, __return_address(), a2, a3, a4, a5, a6, a7, a8);
    *reinterpret_cast<void***>(eax13) = eax12;
    return eax13;
}

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

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

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

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

void fun_10007ddd(void** ecx);

void fun_10007d47(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
    uint32_t edi8;
    struct s50* ebp9;
    struct s51* esi10;
    int32_t ebp11;
    int32_t ebp12;
    int32_t eax13;
    int32_t ebp14;
    int32_t ebp15;
    int32_t ebp16;
    uint32_t v17;

    fun_10004570(0x1000c590, 12, __return_address());
    edi8 = ebp9->f8;
    esi10 = reinterpret_cast<struct s51*>(((edi8 & 31) << 6) + reinterpret_cast<int32_t>(*reinterpret_cast<void**>((reinterpret_cast<int32_t>(edi8) >> 5) * 4 + 0x1000fb40)));
    *reinterpret_cast<int32_t*>(ebp11 - 28) = 1;
    if (!esi10->f8) {
        fun_10006df1(ecx, 10, 0x1000c590, 12, __return_address(), a2, a3, a4, a5, a6, a7);
        ecx = reinterpret_cast<void**>(10);
        *reinterpret_cast<int32_t*>(ebp12 - 4) = 0;
        if (!esi10->f8) {
            eax13 = reinterpret_cast<int32_t>(InitializeCriticalSectionAndSpinCount(10, esi10 + 1, 0xfa0));
            if (!eax13) {
                *reinterpret_cast<int32_t*>(ebp14 - 28) = 0;
            }
            esi10->f8 = esi10->f8 + 1;
        }
        *reinterpret_cast<int32_t*>(ebp15 - 4) = -2;
        fun_10007ddd(10);
    }
    if (*reinterpret_cast<int32_t*>(ebp16 - 28)) {
        v17 = *reinterpret_cast<int32_t*>((reinterpret_cast<int32_t>(edi8) >> 5) * 4 + 0x1000fb40) + ((edi8 & 31) << 6) + 12;
        EnterCriticalSection(ecx, v17);
    }
    fun_100045b5(ecx, 0x1000c590, 12, __return_address(), a2, a3);
    goto 0x1000c590;
}

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

int32_t SetFilePointer = 0xcc2e;

void** fun_10004cd7(void** ecx, void** a2, void** a3, void** a4, void** a5) {
    void** edi6;
    void** esi7;
    void** ebp8;
    void** eax9;
    void** ecx10;
    void** eax11;
    void** eax12;
    unsigned char* eax13;
    void** eax14;
    void** eax15;

    eax9 = fun_10007cde(ecx, a2, edi6, esi7, a3, a4, ebp8, __return_address(), a2);
    if (!reinterpret_cast<int1_t>(eax9 == 0xffffffff)) {
        ecx10 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 + 0xfffffffc);
        eax11 = reinterpret_cast<void**>(SetFilePointer(eax9, a3, ecx10, a5));
        if (!reinterpret_cast<int1_t>(eax11 == 0xffffffff) || (eax12 = reinterpret_cast<void**>(GetLastError(eax9, a3, ecx10, a5)), eax12 == 0)) {
            eax13 = reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>((reinterpret_cast<signed char>(a2) >> 5) * 4 + 0x1000fb40)) + ((reinterpret_cast<unsigned char>(a2) & 31) << 6) + 4);
            *eax13 = reinterpret_cast<unsigned char>(*eax13 & 0xfd);
            eax14 = eax11;
        } else {
            fun_100028bc(ecx10, eax12, eax9, a3, ecx10, a5, edi6, esi7);
            goto addr_10004d08_5;
        }
    } else {
        eax15 = fun_10002896(a2, edi6, esi7, a3, a4, ebp8, __return_address(), a2, a3, a4, a5);
        *reinterpret_cast<void***>(eax15) = reinterpret_cast<void**>(9);
        goto addr_10004d08_5;
    }
    addr_10004d58_7:
    return eax14;
    addr_10004d08_5:
    eax14 = reinterpret_cast<void**>(0xffffffff);
    goto addr_10004d58_7;
}

void** fun_10007e4f(void** a1, void** a2, void** a3, void** a4);

void** fun_10007f65(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
    void** eax7;

    eax7 = fun_10007e4f(a2, a3, a4, 0);
    return eax7;
}

int32_t g1000ddf0 = -2;

void fun_10008b1c(void** a1);

int32_t WriteConsoleW = 0xcd32;

int16_t fun_10007e0d(void** ecx, int16_t a2, void** a3, void** a4) {
    void* ebp5;
    int1_t zf6;
    int32_t eax7;
    int32_t eax8;

    ebp5 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    zf6 = g1000ddf0 == -2;
    if (zf6) {
        fun_10008b1c(ecx);
    }
    eax7 = g1000ddf0;
    if (eax7 == -1 || (eax8 = reinterpret_cast<int32_t>(WriteConsoleW(eax7, reinterpret_cast<int32_t>(ebp5) + 8, 1, reinterpret_cast<int32_t>(ebp5) - 4, 0, ecx)), eax8 == 0)) {
        return -1;
    } else {
        return a2;
    }
}

void fun_10007f80(void** ecx);

int32_t GetConsoleMode = 0xcc5c;

int32_t WideCharToMultiByte = 0xc914;

int32_t GetConsoleCP = 0xcc4c;

struct s52 {
    void** f0;
    signed char[51] pad52;
    signed char f52;
    signed char[3] pad56;
    uint32_t f56;
};

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

void** fun_10004e46(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
    void** v8;
    void** v9;
    void** ebp10;
    void*** ebp11;
    void** v12;
    void** esi13;
    void** v14;
    void** edi15;
    void** v16;
    void** v17;
    void** v18;
    void** v19;
    void** ebx20;
    void*** ebx21;
    void** eax22;
    void* edi23;
    void*** v24;
    void** v25;
    uint32_t eax26;
    void** eax27;
    void** eax28;
    void** eax29;
    void** eax30;
    void** ecx31;
    void** eax32;
    void** ecx33;
    void** v34;
    void** v35;
    void** eax36;
    void** eax37;
    void** v38;
    int32_t eax39;
    void** eax40;
    void** v41;
    void** v42;
    void** v43;
    void* v44;
    void** ecx45;
    void* eax46;
    uint32_t edx47;
    void** esi48;
    void* v49;
    int32_t v50;
    void** v51;
    void** eax52;
    void** ebx53;
    void* v54;
    void* v55;
    uint32_t v56;
    void** v57;
    int32_t eax58;
    void* v59;
    void** eax60;
    void** eax61;
    void** ebx62;
    void* v63;
    void* eax64;
    uint32_t edx65;
    void* esi66;
    void** v67;
    int32_t eax68;
    void* v69;
    void** ebx70;
    uint32_t esi71;
    void* eax72;
    void** dl73;
    void* esi74;
    void** v75;
    int32_t eax76;
    void* v77;
    int32_t eax78;
    void** ebx79;
    int32_t v80;
    void** v81;
    void** esi82;
    void** v83;
    void** eax84;
    struct s52* eax85;
    void** v86;
    uint32_t eax87;
    void** v88;
    void** v89;
    void** eax90;
    void** v91;
    int16_t ax92;
    int16_t ax93;
    void** eax94;
    void* v95;
    void** v96;
    int32_t eax97;
    void* v98;
    void* v99;
    void** v100;
    int32_t eax101;
    void** eax102;
    void** v103;
    int32_t eax104;
    void** eax105;
    void** eax106;
    void** eax107;
    void** eax108;
    void** ecx109;
    void** dl110;

    v8 = reinterpret_cast<void**>(__return_address());
    v9 = ebp10;
    ebp11 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    fun_10007f80(ecx);
    v12 = esi13;
    v14 = edi15;
    v16 = a3;
    v17 = reinterpret_cast<void**>(0);
    v18 = reinterpret_cast<void**>(0);
    if (a4) {
        if (a3) {
            v19 = ebx20;
            ebx21 = reinterpret_cast<void***>((reinterpret_cast<signed char>(a2) >> 5) * 4 + 0x1000fb40);
            eax22 = *ebx21;
            edi23 = reinterpret_cast<void*>((reinterpret_cast<unsigned char>(a2) & 31) << 6);
            ecx = reinterpret_cast<void**>(reinterpret_cast<signed char>(*reinterpret_cast<signed char*>(reinterpret_cast<unsigned char>(eax22) + reinterpret_cast<uint32_t>(edi23) + 36) + *reinterpret_cast<signed char*>(reinterpret_cast<unsigned char>(eax22) + reinterpret_cast<uint32_t>(edi23) + 36)) >> 1);
            v24 = ebx21;
            v25 = ecx;
            if (ecx != 2 && !reinterpret_cast<int1_t>(ecx == 1) || (ecx = reinterpret_cast<void**>(~reinterpret_cast<unsigned char>(a4)), !!(reinterpret_cast<unsigned char>(ecx) & 1))) {
                if (*reinterpret_cast<unsigned char*>(reinterpret_cast<unsigned char>(eax22) + reinterpret_cast<uint32_t>(edi23) + 4) & 32) {
                    fun_10004cd7(ecx, a2, 0, 0, 2);
                }
                eax26 = fun_10005660(ecx, a2, v19, v14, v12, v9, v8, a2, a3);
                if (!eax26) 
                    goto addr_100051c4_7;
                if (*reinterpret_cast<unsigned char*>(reinterpret_cast<uint32_t>(edi23) + reinterpret_cast<unsigned char>(*ebx21) + 4) & 0x80) 
                    goto addr_10004f38_9;
            } else {
                eax27 = fun_100028a9(ecx, v19, v14, v12, v9, v8, a2, a3, a4, a5);
                *reinterpret_cast<void***>(eax27) = reinterpret_cast<void**>(0);
                eax28 = fun_10002896(ecx, v19, v14, v12, v9, v8, a2, a3, a4, a5, a6);
                *reinterpret_cast<void***>(eax28) = reinterpret_cast<void**>(22);
                fun_10002844(ecx);
                goto addr_10005523_11;
            }
        } else {
            eax29 = fun_100028a9(ecx, v14, v12, v9, v8, a2, a3, a4, a5, a6);
            *reinterpret_cast<void***>(eax29) = reinterpret_cast<void**>(0);
            eax30 = fun_10002896(ecx, v14, v12, v9, v8, a2, a3, a4, a5, a6, a7);
            *reinterpret_cast<void***>(eax30) = reinterpret_cast<void**>(22);
            fun_10002844(ecx);
            goto addr_10005535_13;
        }
    } else {
        goto addr_10005535_13;
    }
    addr_100051c4_7:
    ecx31 = reinterpret_cast<void**>(0);
    goto addr_100051c6_15;
    addr_10004f38_9:
    eax32 = fun_100036bd(a2, v19, v14, v12, v9, v8, a2, a3, a4);
    ecx33 = reinterpret_cast<void**>(0);
    *reinterpret_cast<unsigned char*>(&ecx33) = reinterpret_cast<uint1_t>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(eax32 + 0x6c) + 20) == 0);
    v34 = reinterpret_cast<void**>(ebp11 + 0xffffe520);
    v35 = *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(edi23) + reinterpret_cast<unsigned char>(*ebx21));
    eax36 = reinterpret_cast<void**>(GetConsoleMode(v35, v34));
    ecx31 = reinterpret_cast<void**>(0);
    if (!eax36 || ecx33 && !v25) {
        addr_100051c6_15:
        eax37 = *ebx21;
        if (!(*reinterpret_cast<unsigned char*>(reinterpret_cast<unsigned char>(eax37) + reinterpret_cast<uint32_t>(edi23) + 4) & 0x80)) {
            v34 = reinterpret_cast<void**>(0);
            ecx31 = reinterpret_cast<void**>(ebp11 + 0xffffe528);
            v35 = ecx31;
            v38 = *reinterpret_cast<void***>(reinterpret_cast<unsigned char>(eax37) + reinterpret_cast<uint32_t>(edi23));
            eax39 = reinterpret_cast<int32_t>(WriteFile(v38, v16, a4, v35, 0));
            if (!eax39) {
                addr_100054a7_17:
                eax40 = reinterpret_cast<void**>(GetLastError(ecx31, v35, v34));
                v41 = eax40;
            } else {
                v41 = reinterpret_cast<void**>(0);
                v17 = v42;
            }
        } else {
            v41 = reinterpret_cast<void**>(0);
            if (v25) {
                if (!reinterpret_cast<int1_t>(v25 == 2)) {
                    v43 = v16;
                    if (reinterpret_cast<unsigned char>(a4) <= reinterpret_cast<unsigned char>(0)) 
                        goto addr_100054f2_22;
                    do {
                        v44 = reinterpret_cast<void*>(0);
                        ecx45 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v43) - reinterpret_cast<unsigned char>(v16));
                        eax46 = reinterpret_cast<void*>(ebp11 + 0xfffff948);
                        do {
                            if (reinterpret_cast<unsigned char>(ecx45) >= reinterpret_cast<unsigned char>(a4)) 
                                break;
                            edx47 = reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(v43));
                            v43 = v43 + 2;
                            ecx45 = ecx45 + 2;
                            if (edx47 == 10) {
                                eax46 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(eax46) + 2);
                                v44 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(v44) + 2);
                            }
                            v44 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(v44) + 2);
                            eax46 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(eax46) + 2);
                        } while (reinterpret_cast<uint32_t>(v44) < 0x6a8);
                        esi48 = reinterpret_cast<void**>(0);
                        v34 = reinterpret_cast<void**>(0);
                        v35 = reinterpret_cast<void**>(0);
                        v49 = reinterpret_cast<void*>(ebp11 + 0xffffebf0);
                        ecx31 = reinterpret_cast<void**>(ebp11 + 0xfffff948);
                        __asm__("cdq ");
                        v50 = reinterpret_cast<int32_t>(reinterpret_cast<uint32_t>(eax46) - reinterpret_cast<unsigned char>(ecx31) - edx47) >> 1;
                        v51 = ecx31;
                        eax52 = reinterpret_cast<void**>(WideCharToMultiByte(0xfde9, 0, v51, v50, v49, 0xd55, 0, 0));
                        ebx53 = eax52;
                        if (!ebx53) 
                            goto addr_100054a7_17;
                        do {
                            v54 = reinterpret_cast<void*>(ebp11 + 0xffffe528);
                            v55 = reinterpret_cast<void*>(reinterpret_cast<unsigned char>(ebx53) - reinterpret_cast<unsigned char>(esi48));
                            v56 = reinterpret_cast<uint32_t>(ebp11) + reinterpret_cast<unsigned char>(esi48) + 0xffffebf0;
                            v57 = *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(edi23) + reinterpret_cast<unsigned char>(*v24));
                            eax58 = reinterpret_cast<int32_t>(WriteFile(v57, v56, v55, v54, 0, 0xfde9, 0, v51, v50, v49, 0xd55, 0, 0));
                            if (!eax58) 
                                break;
                            esi48 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi48) + reinterpret_cast<uint32_t>(v59));
                        } while (reinterpret_cast<signed char>(ebx53) > reinterpret_cast<signed char>(esi48));
                        goto addr_10005445_31;
                        eax60 = reinterpret_cast<void**>(GetLastError(v57, v56, v55, v54, 0, 0xfde9, 0, v51, v50, v49, 0xd55, 0, 0));
                        v41 = eax60;
                        addr_10005453_33:
                        if (reinterpret_cast<signed char>(ebx53) > reinterpret_cast<signed char>(esi48)) 
                            break; else 
                            continue;
                        addr_10005445_31:
                        goto addr_10005453_33;
                        eax61 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v43) - reinterpret_cast<unsigned char>(v16));
                        v17 = eax61;
                    } while (reinterpret_cast<unsigned char>(eax61) < reinterpret_cast<unsigned char>(a4));
                    goto addr_10005472_35;
                } else {
                    ebx62 = v16;
                    if (reinterpret_cast<unsigned char>(a4) <= reinterpret_cast<unsigned char>(0)) 
                        goto addr_100054f2_22;
                    do {
                        v63 = reinterpret_cast<void*>(0);
                        ecx31 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ebx62) - reinterpret_cast<unsigned char>(v16));
                        eax64 = reinterpret_cast<void*>(ebp11 + 0xffffe548);
                        do {
                            if (reinterpret_cast<unsigned char>(ecx31) >= reinterpret_cast<unsigned char>(a4)) 
                                break;
                            edx65 = reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(ebx62));
                            ebx62 = ebx62 + 2;
                            ecx31 = ecx31 + 2;
                            if (edx65 == 10) {
                                ebx62 = ebx62;
                                eax64 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(eax64) + 2);
                                v63 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(v63) + 2);
                            }
                            v63 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(v63) + 2);
                            eax64 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(eax64) + 2);
                        } while (reinterpret_cast<uint32_t>(v63) < 0x13fe);
                        esi66 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(eax64) - reinterpret_cast<uint32_t>(ebp11 + 0xffffe548));
                        v34 = reinterpret_cast<void**>(0);
                        v35 = reinterpret_cast<void**>(ebp11 + 0xffffe528);
                        v67 = *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(edi23) + reinterpret_cast<unsigned char>(*v24));
                        eax68 = reinterpret_cast<int32_t>(WriteFile(v67, ebp11 + 0xffffe548, esi66, v35, 0));
                        if (!eax68) 
                            goto addr_100054a7_17;
                        v17 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v17) + reinterpret_cast<uint32_t>(v69));
                        if (reinterpret_cast<int32_t>(v69) < reinterpret_cast<int32_t>(esi66)) 
                            break;
                    } while (reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(ebx62) - reinterpret_cast<unsigned char>(v16)) < reinterpret_cast<unsigned char>(a4));
                    goto addr_10005363_45;
                }
            } else {
                ebx70 = v16;
                if (reinterpret_cast<unsigned char>(a4) <= reinterpret_cast<unsigned char>(0)) 
                    goto addr_100054f2_22;
                do {
                    esi71 = 0;
                    ecx31 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ebx70) - reinterpret_cast<unsigned char>(v16));
                    eax72 = reinterpret_cast<void*>(ebp11 + 0xffffe548);
                    do {
                        if (reinterpret_cast<unsigned char>(ecx31) >= reinterpret_cast<unsigned char>(a4)) 
                            break;
                        dl73 = *reinterpret_cast<void***>(ebx70);
                        ++ebx70;
                        ++ecx31;
                        if (reinterpret_cast<int1_t>(dl73 == 10)) {
                            eax72 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(eax72) + 1);
                            ++esi71;
                        }
                        eax72 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(eax72) + 1);
                        ++esi71;
                    } while (esi71 < 0x13ff);
                    esi74 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(eax72) - reinterpret_cast<uint32_t>(ebp11 + 0xffffe548));
                    v34 = reinterpret_cast<void**>(0);
                    v35 = reinterpret_cast<void**>(ebp11 + 0xffffe528);
                    v75 = *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(edi23) + reinterpret_cast<unsigned char>(*v24));
                    eax76 = reinterpret_cast<int32_t>(WriteFile(v75, ebp11 + 0xffffe548, esi74, v35, 0));
                    if (!eax76) 
                        goto addr_100054a7_17;
                    v17 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v17) + reinterpret_cast<uint32_t>(v77));
                    if (reinterpret_cast<int32_t>(v77) < reinterpret_cast<int32_t>(esi74)) 
                        break;
                } while (reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(ebx70) - reinterpret_cast<unsigned char>(v16)) < reinterpret_cast<unsigned char>(a4));
                goto addr_10005289_55;
            }
        }
    } else {
        eax78 = reinterpret_cast<int32_t>(GetConsoleCP(v35, v34));
        ebx79 = v16;
        v80 = eax78;
        if (reinterpret_cast<unsigned char>(a4) <= reinterpret_cast<unsigned char>(0)) 
            goto addr_100054bc_57;
        v81 = reinterpret_cast<void**>(0);
        do {
            if (v25) {
                if (v25 == 1 || reinterpret_cast<int1_t>(v25 == 2)) {
                    esi82 = reinterpret_cast<void**>(static_cast<uint32_t>(reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(ebx79))));
                    ecx31 = reinterpret_cast<void**>(0);
                    ecx31 = reinterpret_cast<void**>(static_cast<unsigned char>(reinterpret_cast<uint1_t>(esi82 == 10)));
                    ebx79 = ebx79 + 2;
                    v81 = v81 + 2;
                    v41 = esi82;
                    v83 = ecx31;
                }
                if (v25 == 1) 
                    goto addr_10005145_63;
                if (!reinterpret_cast<int1_t>(v25 == 2)) 
                    continue;
            } else {
                ecx31 = *reinterpret_cast<void***>(ebx79);
                eax84 = reinterpret_cast<void**>(0);
                *reinterpret_cast<unsigned char*>(&eax84) = reinterpret_cast<uint1_t>(ecx31 == 10);
                v83 = eax84;
                eax85 = reinterpret_cast<struct s52*>(reinterpret_cast<unsigned char>(*v24) + reinterpret_cast<uint32_t>(edi23));
                if (!eax85->f56) {
                    v86 = reinterpret_cast<void**>(static_cast<int32_t>(reinterpret_cast<signed char>(ecx31)));
                    eax87 = fun_10005b05(ecx31, v86, v35, v34);
                    ecx31 = v86;
                    if (!eax87) {
                        v88 = reinterpret_cast<void**>(1);
                        v89 = ebx79;
                        goto addr_1000502d_68;
                    } else {
                        ecx31 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v16) - reinterpret_cast<unsigned char>(ebx79) + reinterpret_cast<unsigned char>(a4));
                        if (reinterpret_cast<unsigned char>(ecx31) <= reinterpret_cast<unsigned char>(1)) 
                            goto addr_100051ab_70;
                        eax90 = fun_10007f65(ecx31, ebp11 + 0xffffe544, ebx79, 2, v35, v34);
                        if (eax90 == 0xffffffff) 
                            break;
                        ++ebx79;
                        ++v81;
                        goto addr_10005045_73;
                    }
                } else {
                    *reinterpret_cast<signed char*>(&v19) = eax85->f52;
                    (&v19)[1] = ecx31;
                    eax85->f56 = 0;
                    v88 = reinterpret_cast<void**>(2);
                    v89 = reinterpret_cast<void**>(ebp11 + 0xfffffff4);
                    goto addr_1000502d_68;
                }
            }
            addr_10005145_63:
            v91 = v41;
            ax92 = fun_10007e0d(ecx31, *reinterpret_cast<int16_t*>(&v91), v35, v34);
            ecx31 = v91;
            if (ax92 != *reinterpret_cast<int16_t*>(&v41)) 
                goto addr_100054a7_17;
            v17 = v17 + 2;
            if (!v83) 
                continue;
            v41 = reinterpret_cast<void**>(13);
            ax93 = fun_10007e0d(ecx31, 13, v35, v34);
            ecx31 = reinterpret_cast<void**>(13);
            if (ax93 != 13) 
                goto addr_100054a7_17;
            ++v17;
            ++v18;
            continue;
            addr_1000502d_68:
            eax94 = fun_10007f65(ecx31, ebp11 + 0xffffe544, v89, v88, v35, v34);
            if (eax94 == 0xffffffff) 
                break;
            addr_10005045_73:
            v95 = reinterpret_cast<void*>(ebp11 + 0xfffffff4);
            ecx31 = reinterpret_cast<void**>(ebp11 + 0xffffe544);
            v96 = ecx31;
            ++ebx79;
            ++v81;
            eax97 = reinterpret_cast<int32_t>(WideCharToMultiByte(v80, 0, v96, 1, v95, 5, 0, 0, v35, v34));
            if (!eax97) 
                break;
            v98 = reinterpret_cast<void*>(ebp11 + 0xffffe52c);
            v99 = reinterpret_cast<void*>(ebp11 + 0xfffffff4);
            v100 = *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(edi23) + reinterpret_cast<unsigned char>(*v24));
            eax101 = reinterpret_cast<int32_t>(WriteFile(v100, v99, eax97, v98, 0, v80, 0, v96, 1, v95, 5, 0, 0, v35, v34));
            if (!eax101) 
                goto addr_100054a7_17;
            ecx31 = v18;
            v17 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v81) + reinterpret_cast<unsigned char>(ecx31));
            if (0 < eax97) 
                break;
            if (v83) {
                eax102 = *v24;
                *reinterpret_cast<signed char*>(&v19) = 13;
                v103 = *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(edi23) + reinterpret_cast<unsigned char>(eax102));
                eax104 = reinterpret_cast<int32_t>(WriteFile(v103, ebp11 + 0xfffffff4, 1, ebp11 + 0xffffe52c, 0, v100, v99, eax97, v98, 0, v80, 0, v96, 1, v95, 5, 0, 0, v35, v34));
                if (!eax104) 
                    goto addr_100054a7_17;
                if (1) 
                    break;
                ++v18;
                ++v17;
            }
        } while (reinterpret_cast<unsigned char>(v81) < reinterpret_cast<unsigned char>(a4));
        goto addr_100051a6_85;
    }
    addr_100054b3_86:
    if (!v17) {
        addr_100054bc_57:
        if (!v41) {
            addr_100054f2_22:
            if (!(*reinterpret_cast<unsigned char*>(reinterpret_cast<uint32_t>(edi23) + reinterpret_cast<unsigned char>(*v24) + 4) & 64) || !reinterpret_cast<int1_t>(*reinterpret_cast<void***>(v16) == 26)) {
                eax105 = fun_10002896(ecx31, v19, v14, v12, v9, v8, a2, a3, a4, a5, a6);
                *reinterpret_cast<void***>(eax105) = reinterpret_cast<void**>(28);
                eax106 = fun_100028a9(ecx31, v19, v14, v12, v9, v8, a2, a3, a4, a5);
                *reinterpret_cast<void***>(eax106) = reinterpret_cast<void**>(0);
                goto addr_10005523_11;
            }
        } else {
            if (!reinterpret_cast<int1_t>(v41 == 5)) {
                fun_100028bc(ecx31, v41, v35, v34, v19, v14, v12, v9);
                goto addr_10005523_11;
            } else {
                eax107 = fun_10002896(ecx31, v35, v34, v19, v14, v12, v9, v8, a2, a3, a4);
                *reinterpret_cast<void***>(eax107) = reinterpret_cast<void**>(9);
                eax106 = fun_100028a9(ecx31, v35, v34, v19, v14, v12, v9, v8, a2, a3);
                *reinterpret_cast<void***>(eax106) = reinterpret_cast<void**>(5);
                goto addr_10005523_11;
            }
        }
    }
    addr_10005534_93:
    addr_10005535_13:
    eax108 = fun_10001cc4(reinterpret_cast<unsigned char>(v12) ^ reinterpret_cast<uint32_t>(ebp11), v9);
    return eax108;
    addr_10005523_11:
    goto addr_10005534_93;
    addr_10005472_35:
    goto addr_100054b3_86;
    addr_10005363_45:
    goto addr_100054b3_86;
    addr_10005289_55:
    goto addr_100054b3_86;
    addr_100051a6_85:
    goto addr_100054b3_86;
    addr_100051ab_70:
    ecx109 = *v24;
    dl110 = *reinterpret_cast<void***>(ebx79);
    ++v17;
    *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(edi23) + reinterpret_cast<unsigned char>(ecx109) + 52) = dl110;
    ecx31 = *v24;
    *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(edi23) + reinterpret_cast<unsigned char>(ecx31) + 56) = reinterpret_cast<void**>(1);
    goto addr_100054b3_86;
}

void** g1000fb20;

void** g1000eb04;

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

void fun_1000803f(void** ecx);

void fun_10007fac(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14) {
    void** v15;
    int32_t ebp16;
    void** ecx17;
    int32_t ebp18;
    void** edi19;
    int32_t ebp20;
    int1_t less21;
    void** eax22;
    void** v23;
    int32_t eax24;
    int32_t ebp25;
    int32_t ebp26;
    void** eax27;
    void** v28;
    void** eax29;
    void** v30;
    void** eax31;
    int32_t ebp32;

    v15 = reinterpret_cast<void**>(__return_address());
    fun_10004570(0x1000c5b0, 16, v15);
    *reinterpret_cast<void***>(ebp16 - 28) = reinterpret_cast<void**>(0);
    fun_10006df1(ecx, 1, 0x1000c5b0, 16, v15, a2, a3, a4, a5, a6, a7);
    ecx17 = reinterpret_cast<void**>(1);
    *reinterpret_cast<void***>(ebp18 - 4) = reinterpret_cast<void**>(0);
    edi19 = reinterpret_cast<void**>(3);
    while (*reinterpret_cast<void***>(ebp20 - 32) = edi19, less21 = reinterpret_cast<signed char>(edi19) < reinterpret_cast<signed char>(g1000fb20), less21) {
        eax22 = g1000eb04;
        if (*reinterpret_cast<void***>(eax22 + reinterpret_cast<unsigned char>(edi19) * 4)) {
            if (reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(eax22 + reinterpret_cast<unsigned char>(edi19) * 4) + 12)) & 0x83 && (v23 = *reinterpret_cast<void***>(eax22 + reinterpret_cast<unsigned char>(edi19) * 4), eax24 = fun_10008bbf(ecx17, v23, 0x1000c5b0, 16, v15, a2, a3, a4, a5, a6), ecx17 = v23, eax24 != -1)) {
                *reinterpret_cast<int32_t*>(ebp25 - 28) = *reinterpret_cast<int32_t*>(ebp26 - 28) + 1;
            }
            if (reinterpret_cast<signed char>(edi19) >= reinterpret_cast<signed char>(20)) {
                eax27 = g1000eb04;
                v28 = *reinterpret_cast<void***>(eax27 + reinterpret_cast<unsigned char>(edi19) * 4) + 32;
                DeleteCriticalSection(ecx17, v28);
                eax29 = g1000eb04;
                v30 = *reinterpret_cast<void***>(eax29 + reinterpret_cast<unsigned char>(edi19) * 4);
                fun_10002416(ecx17, v30, v28, 0x1000c5b0, 16, v15, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
                ecx17 = v30;
                eax31 = g1000eb04;
                *reinterpret_cast<void***>(eax31 + reinterpret_cast<unsigned char>(edi19) * 4) = reinterpret_cast<void**>(0);
            }
        }
        ++edi19;
    }
    *reinterpret_cast<int32_t*>(ebp32 - 4) = -2;
    fun_1000803f(ecx17);
    fun_100045b5(ecx17, 0x1000c5b0, 16, v15, a2, a3);
    goto 0x1000c5b0;
}

void fun_1000578d(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6) {
    void** ecx7;
    void** esi8;
    void** ebp9;

    if (reinterpret_cast<unsigned char>(a1) < reinterpret_cast<unsigned char>(0x1000d990) || reinterpret_cast<unsigned char>(a1) > reinterpret_cast<unsigned char>(0x1000dbf0)) {
        EnterCriticalSection(a1 + 32);
    } else {
        ecx7 = reinterpret_cast<void**>((reinterpret_cast<int32_t>(reinterpret_cast<unsigned char>(a1) - reinterpret_cast<unsigned char>(0x1000d990)) >> 5) + 16);
        fun_10006df1(ecx7, ecx7, esi8, ebp9, __return_address(), a1, a2, a3, a4, a5, a6);
        *reinterpret_cast<void***>(a1 + 12) = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a1 + 12)) | 0x8000);
    }
    return;
}

uint32_t g1000e2f4;

int32_t fun_100058b4() {
    void** eax1;
    int32_t ecx2;
    uint1_t zf3;

    eax1 = g1000d050;
    ecx2 = 0;
    zf3 = reinterpret_cast<uint1_t>(g1000e2f4 == (reinterpret_cast<unsigned char>(eax1) | 1));
    *reinterpret_cast<unsigned char*>(&ecx2) = zf3;
    return ecx2;
}

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

void** fun_10005ab0(void** ecx, void** a2, void** a3, void** a4, uint32_t a5) {
    uint32_t v6;
    void** eax7;

    v6 = a5;
    eax7 = fun_1000595b(ecx, a2, a3, a4, *reinterpret_cast<uint16_t*>(&v6), 0);
    return eax7;
}

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

uint32_t fun_10005b05(void** ecx, void** a2, void** a3, void** a4) {
    void** ebp5;
    uint32_t eax6;

    eax6 = fun_10005acd(ecx, a2, 0, ebp5);
    return eax6;
}

void fun_10005c3a(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
    signed char al7;
    uint32_t eax8;
    void** al9;
    unsigned char al10;
    uint32_t* esi11;
    uint32_t* esi12;
    int32_t* esi13;
    int32_t* esi14;

    if (!(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(ecx + 12)) & 64) || *reinterpret_cast<void***>(ecx + 8)) {
        *reinterpret_cast<void***>(ecx + 4) = *reinterpret_cast<void***>(ecx + 4) - 1;
        if (reinterpret_cast<signed char>(*reinterpret_cast<void***>(ecx + 4)) < reinterpret_cast<signed char>(0)) {
            eax8 = fun_10002556(ecx, static_cast<int32_t>(al7), ecx, __return_address(), a2, a3, a4);
        } else {
            *reinterpret_cast<void***>(*reinterpret_cast<void***>(ecx)) = al9;
            *reinterpret_cast<void***>(ecx) = *reinterpret_cast<void***>(ecx) + 1;
            eax8 = al10;
        }
        if (eax8 == 0xffffffff) {
            *esi11 = *esi12 | eax8;
            return;
        }
    }
    *esi13 = *esi14 + 1;
    return;
}

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

    if (a2) {
        return *reinterpret_cast<void***>(a2 + 16);
    } else {
        eax11 = fun_10002896(ecx, ebp10, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
        *reinterpret_cast<void***>(eax11) = reinterpret_cast<void**>(22);
        fun_10002844(ecx);
        return 0xffffffff;
    }
}

void** fun_10005b20(void** a1, void** a2, void** a3, void** a4) {
    void** ecx5;
    void** ebx6;
    void** eax7;
    void** eax8;
    void** esi9;
    void** tmp32_10;

    if (a4) {
        ecx5 = a4;
        ebx6 = a3;
        eax7 = a1;
        do {
            ecx5 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx5) >> 1);
            __asm__("rcr ebx, 1");
            __asm__("rcr eax, 1");
        } while (ecx5);
        eax8 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax7) / reinterpret_cast<unsigned char>(ebx6));
        esi9 = eax8;
        tmp32_10 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(__intrinsic()) + reinterpret_cast<unsigned char>(eax8) * reinterpret_cast<unsigned char>(a4));
        if (reinterpret_cast<unsigned char>(tmp32_10) < reinterpret_cast<unsigned char>(__intrinsic())) 
            goto addr_10005b8d_5;
        if (reinterpret_cast<unsigned char>(tmp32_10) > reinterpret_cast<unsigned char>(a2)) 
            goto addr_10005b8d_5;
        if (reinterpret_cast<unsigned char>(tmp32_10) < reinterpret_cast<unsigned char>(a2)) 
            goto addr_10005b96_8;
        if (reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(a3) * reinterpret_cast<unsigned char>(esi9)) <= reinterpret_cast<unsigned char>(a1)) 
            goto addr_10005b96_8;
    } else {
        esi9 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(a1) / reinterpret_cast<unsigned char>(a3));
        goto addr_10005b98_11;
    }
    addr_10005b8d_5:
    --esi9;
    addr_10005b96_8:
    addr_10005b98_11:
    return esi9;
}

struct s53 {
    signed char[12] pad12;
    unsigned char f12;
};

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

void fun_10005c6d(void** ecx) {
    void** v2;
    void*** edi3;
    void*** edi4;
    void** v5;
    void** ebp6;
    int1_t zf7;
    struct s53* ebx8;
    void** v9;
    void** esi10;
    int32_t* esi11;
    int32_t* eax12;
    void** v13;
    struct s54* ebx14;
    int32_t v15;
    int32_t v16;
    void** ebx17;
    void** v18;
    void** ebx19;
    int32_t v20;

    v2 = reinterpret_cast<void**>(__return_address());
    edi3 = edi4;
    v5 = ebp6;
    zf7 = (ebx8->f12 & 64) == 0;
    v9 = esi10;
    esi11 = eax12;
    v13 = *edi3;
    if (zf7 || ebx14->f8) {
        *edi3 = reinterpret_cast<void**>(0);
        if (v15 <= 0) {
            addr_10005cc7_3:
            *edi3 = v13;
        } else {
            do {
                --v16;
                fun_10005c3a(ebx17, v9, v13, v5, v2, v18);
                ++v18;
                if (*esi11 == -1) {
                    if (!reinterpret_cast<int1_t>(*edi3 == 42)) 
                        break;
                    fun_10005c3a(ebx19, v9, v13, v5, v2, v18);
                }
            } while (v16 > 0);
            if (!*edi3) 
                goto addr_10005cc7_3;
        }
    } else {
        *esi11 = *esi11 + v20;
    }
    return;
}

void fun_100082b0(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void** a16, void** a17, void** a18, void** a19) {
    int32_t v20;
    void* esp21;
    uint32_t ecx22;
    int32_t eax23;
    uint32_t tmp32_24;
    int32_t eax25;
    void* eax26;
    uint32_t eax27;
    void* esp28;
    void* ecx29;
    int32_t* ecx30;
    int32_t* eax31;

    v20 = reinterpret_cast<int32_t>(__return_address());
    esp21 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    ecx22 = reinterpret_cast<uint32_t>(reinterpret_cast<int32_t>(esp21) + 8 - eax23) & 15;
    tmp32_24 = eax25 + ecx22;
    eax26 = reinterpret_cast<void*>(tmp32_24 | ecx22 - (ecx22 + reinterpret_cast<uint1_t>(ecx22 < ecx22 + reinterpret_cast<uint1_t>(tmp32_24 < eax27))));
    esp28 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(esp21) + 4 - 4);
    ecx29 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp28) + 4);
    ecx30 = reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(ecx29) - reinterpret_cast<uint32_t>(eax26) & ~(reinterpret_cast<uint32_t>(eax26) - (reinterpret_cast<uint32_t>(eax26) + reinterpret_cast<uint1_t>(reinterpret_cast<uint32_t>(eax26) < reinterpret_cast<uint32_t>(eax26) + reinterpret_cast<uint1_t>(reinterpret_cast<uint32_t>(ecx29) < reinterpret_cast<uint32_t>(eax26))))));
    eax31 = reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esp28) & 0xfffff000);
    while (reinterpret_cast<uint32_t>(ecx30) < reinterpret_cast<uint32_t>(eax31)) {
        eax31 = eax31 - 0x400;
    }
    *ecx30 = v20;
    goto *ecx30;
}

int32_t MultiByteToWideChar = 0xccae;

int32_t GetStringTypeW = 0xccc4;

void** fun_10006b50(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8) {
    void*** esp9;
    void** eax10;
    void** v11;
    void** ebx12;
    void** v13;
    int32_t esi14;
    int32_t eax15;
    void** v16;
    void** v17;
    void** eax18;
    void** edi19;
    void** esi20;
    int32_t eax21;
    void** eax22;
    void** ebx23;
    void** ebp24;
    void** eax25;
    void** eax26;
    void** eax27;

    esp9 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    eax10 = g1000d050;
    v11 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax10) ^ reinterpret_cast<uint32_t>(esp9));
    ebx12 = reinterpret_cast<void**>(0);
    v13 = reinterpret_cast<void**>(0);
    if (!a7) {
        a7 = *reinterpret_cast<void***>(*reinterpret_cast<void***>(a2) + 4);
    }
    esi14 = MultiByteToWideChar;
    eax15 = 0;
    *reinterpret_cast<unsigned char*>(&eax15) = reinterpret_cast<uint1_t>(!!a8);
    v16 = reinterpret_cast<void**>(eax15 * 8 + 1);
    v17 = a7;
    eax18 = reinterpret_cast<void**>(esi14(v17, v16, a4, a5, 0, 0));
    if (!eax18) 
        goto addr_10006ba2_4;
    if (reinterpret_cast<signed char>(eax18) <= reinterpret_cast<signed char>(0) || reinterpret_cast<unsigned char>(eax18) > reinterpret_cast<unsigned char>(0x7ffffff0)) {
        addr_10006be4_6:
        if (!ebx12) {
            addr_10006ba2_4:
        } else {
            fun_10005bc0(ecx, ebx12, 0, reinterpret_cast<unsigned char>(eax18) + reinterpret_cast<unsigned char>(eax18), v17, v16, a4, a5, 0, 0, edi19, esi20);
            eax21 = reinterpret_cast<int32_t>(esi14(ecx, a7, 1, a4, a5, ebx12, eax18, v17, v16, a4, a5, 0, 0));
            if (eax21) {
                eax22 = reinterpret_cast<void**>(GetStringTypeW(ecx, a3, ebx12, eax21, a6, a7, 1, a4, a5, ebx12, eax18, v17, v16, a4, a5, 0, 0));
                v13 = eax22;
            }
            fun_10006903(ecx, ebx12, a7, 1, a4, a5, ebx12, eax18, v17, v16, a4, a5, 0, 0, edi19, esi20, ebx23, v13, v11, ebp24, __return_address(), a2, a3, a4, a5, a6);
        }
    } else {
        eax25 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax18) + reinterpret_cast<unsigned char>(eax18) + 8);
        if (reinterpret_cast<unsigned char>(eax25) > reinterpret_cast<unsigned char>(0x400)) {
            eax26 = fun_10004bb8(ecx, eax25, v17, v16, a4, a5, 0, 0, edi19, esi20, ebx23, 0, v11, ebp24, __return_address(), a2, a3, a4, a5, a6);
            ecx = eax25;
            if (!eax26) {
                addr_10006be2_12:
                ebx12 = eax26;
                goto addr_10006be4_6;
            } else {
                *reinterpret_cast<void***>(eax26) = reinterpret_cast<void**>(0xdddd);
                goto addr_10006bdf_14;
            }
        } else {
            fun_100082b0(ecx, v17, v16, a4, a5, 0, 0, edi19, esi20, ebx23, 0, v11, ebp24, __return_address(), a2, a3, a4, a5, a6);
            eax26 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esp9 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 + 4) - 4 + 4);
            if (!eax26) 
                goto addr_10006be2_12;
            v17 = reinterpret_cast<void**>(0xcccc);
            goto addr_10006bdf_14;
        }
    }
    eax27 = fun_10001cc4(reinterpret_cast<unsigned char>(v11) ^ reinterpret_cast<uint32_t>(esp9), v13);
    return eax27;
    addr_10006bdf_14:
    eax26 = eax26 + 8;
    goto addr_10006be2_12;
}

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

void fun_10006de8(void** ecx);

int32_t fun_10006d2f(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15) {
    int32_t ebp16;
    int1_t zf17;
    void*** esi18;
    struct s55* ebp19;
    void** eax20;
    int32_t ebp21;
    int32_t eax22;
    void** eax23;
    int32_t ebp24;
    int32_t ebp25;
    void** eax26;

    fun_10004570(0x1000c510, 12, __return_address());
    *reinterpret_cast<int32_t*>(ebp16 - 28) = 1;
    zf17 = g1000e2e8 == 0;
    if (zf17) {
        fun_10007b81(ecx, 0x1000c510, 12, __return_address(), a2, a3, a4);
        fun_100079d2(ecx, 30, 0x1000c510, 12, __return_address());
        fun_10003bf2(ecx, 0xff, 30, 0x1000c510, 12, __return_address(), a2);
        ecx = reinterpret_cast<void**>(30);
    }
    esi18 = reinterpret_cast<void***>(ebp19->f8 * 8 + 0x1000dc40);
    if (!*esi18) {
        eax20 = fun_10003ae8(ecx, 24, 0x1000c510, 12, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
        ecx = reinterpret_cast<void**>(24);
        if (eax20) {
            fun_10006df1(24, 10, 0x1000c510, 12, __return_address(), a2, a3, a4, a5, a6, a7);
            ecx = reinterpret_cast<void**>(10);
            *reinterpret_cast<void***>(ebp21 - 4) = reinterpret_cast<void**>(0);
            if (*esi18) {
                fun_10002416(10, eax20, 0x1000c510, 12, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
                ecx = eax20;
            } else {
                eax22 = reinterpret_cast<int32_t>(InitializeCriticalSectionAndSpinCount(10, eax20, 0xfa0));
                if (eax22) {
                    *esi18 = eax20;
                } else {
                    fun_10002416(10, eax20, eax20, 0xfa0, 0x1000c510, 12, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
                    ecx = eax20;
                    eax23 = fun_10002896(ecx, eax20, 0xfa0, 0x1000c510, 12, __return_address(), a2, a3, a4, a5, a6);
                    *reinterpret_cast<void***>(eax23) = reinterpret_cast<void**>(12);
                    *reinterpret_cast<void***>(ebp24 - 28) = reinterpret_cast<void**>(0);
                }
            }
            *reinterpret_cast<int32_t*>(ebp25 - 4) = -2;
            fun_10006de8(ecx);
        } else {
            eax26 = fun_10002896(24, 0x1000c510, 12, __return_address(), a2, a3, a4, a5, a6, a7, a8);
            *reinterpret_cast<void***>(eax26) = reinterpret_cast<void**>(12);
        }
    }
    fun_100045b5(ecx, 0x1000c510, 12, __return_address(), a2, a3);
    goto 0x1000c510;
}

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

int32_t g1000ddd8 = 0;

int32_t g1000ddd4 = 0;

int32_t g1000dddc = 0;

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

    g1000ddd8 = a2;
    g1000ddd4 = eax10;
    g1000dddc = ebp11;
    return eax12;
}

void fun_10008414(void** ecx, void** a2, void** a3, uint32_t a4, void** a5, void** a6, void** a7, struct s56* a8) {
    int32_t eax9;

    eax9();
    return;
}

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

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

int32_t fun_10007400(struct s58* a1, uint32_t a2);

void fun_10007370(void** a1, void** a2, void** a3) {
    struct s56* v4;
    struct s56* ebp5;
    void** v6;
    void** v7;
    void** v8;
    void** esp9;
    void** v10;
    void** eax11;
    uint32_t v12;
    struct s57* ebx13;
    void** ecx14;

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

int32_t SetLastError = 0xca9e;

void** fun_10003644(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11) {
    void** v12;
    int32_t eax13;
    void** eax14;
    void** edi15;
    void** esi16;
    void** eax17;
    void** v18;
    void** v19;
    int32_t eax20;
    int32_t eax21;
    void** eax22;

    GetLastError();
    v12 = g1000d93c;
    eax13 = fun_1000351f();
    eax14 = reinterpret_cast<void**>(eax13());
    if (!eax14 && (eax17 = fun_10003b2d(ecx, 1, 0x214, v12, edi15, esi16, __return_address(), a2, a3, a4, a5), ecx = reinterpret_cast<void**>(0x214), !!eax17)) {
        v18 = g1000d93c;
        v19 = g1000e194;
        eax20 = reinterpret_cast<int32_t>(DecodePointer(0x214, v19, v18, eax17));
        eax21 = reinterpret_cast<int32_t>(eax20(0x214, v19, v18, eax17));
        if (!eax21) {
            fun_10002416(0x214, eax17, v19, v18, eax17, v12, edi15, esi16, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
            ecx = eax17;
        } else {
            fun_10003590(0x214, eax17, 0, v19, v18, eax17, v12, edi15, esi16, __return_address(), a2, a3, a4, a5);
            ecx = reinterpret_cast<void**>(0);
            eax22 = reinterpret_cast<void**>(GetCurrentThreadId(0, v19, v18, eax17));
            *reinterpret_cast<void***>(eax17 + 4) = reinterpret_cast<void**>(0xffffffff);
            *reinterpret_cast<void***>(eax17) = eax22;
        }
    }
    SetLastError(ecx);
    goto edi15;
}

void** fun_10003e4a(void** ecx, void** a2, void** a3, void** a4, void** a5) {
    void** ebp6;
    void** eax7;

    eax7 = fun_10003d0a(ecx, a2, 1, 0, ebp6, __return_address(), a2);
    return eax7;
}

struct s59 {
    signed char[6] pad6;
    uint16_t f6;
    signed char[12] pad20;
    uint16_t f20;
};

struct s48* fun_100078a0(struct s49* a1, uint32_t a2) {
    struct s59* ecx3;
    uint32_t eax4;
    uint32_t esi5;
    uint32_t edx6;
    struct s48* eax7;
    uint32_t edi8;

    ecx3 = reinterpret_cast<struct s59*>(a1->f60 + reinterpret_cast<int32_t>(a1));
    eax4 = ecx3->f20;
    esi5 = ecx3->f6;
    edx6 = 0;
    eax7 = reinterpret_cast<struct s48*>(eax4 + reinterpret_cast<int32_t>(ecx3) + 24);
    if (!esi5) {
        addr_100078dd_2:
        eax7 = reinterpret_cast<struct s48*>(0);
    } else {
        edi8 = a2;
        do {
            if (edi8 < eax7->f12) 
                continue;
            if (edi8 < eax7->f8 + eax7->f12) 
                break;
            ++edx6;
            ++eax7;
        } while (edx6 < esi5);
        goto addr_100078dd_2;
    }
    return eax7;
}

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

void** fun_10008add(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9) {
    void** eax10;
    void** eax11;
    void** ebp12;
    void** eax13;

    if (reinterpret_cast<signed char>(a2) >= reinterpret_cast<signed char>(0)) {
        if (reinterpret_cast<signed char>(a2) <= reinterpret_cast<signed char>(2)) {
            eax10 = g1000de2c;
            g1000de2c = a2;
            return eax10;
        } else {
            if (reinterpret_cast<int1_t>(a2 == 3)) {
                eax11 = g1000de2c;
                return eax11;
            }
        }
    }
    eax13 = fun_10002896(a2, ebp12, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
    *reinterpret_cast<void***>(eax13) = reinterpret_cast<void**>(22);
    fun_10002844(a2);
    return 0xffffffff;
}

void** fun_10008a7a(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
    void** v8;
    void** v9;
    void** ebp10;
    void** v11;
    void** esi12;
    void** esi13;
    void** v14;
    void** edi15;
    void** edi16;
    void** eax17;
    void** esi18;
    void** eax19;
    void* edx20;
    void** ecx21;
    void** eax22;
    void** eax23;

    v8 = reinterpret_cast<void**>(__return_address());
    v9 = ebp10;
    v11 = esi12;
    esi13 = a2;
    v14 = edi15;
    if (!esi13 || (edi16 = a3, !edi16)) {
        addr_10008a8f_2:
        eax17 = fun_10002896(ecx, v14, v11, v9, v8, a2, a3, a4, a5, a6, a7);
        esi18 = reinterpret_cast<void**>(22);
        *reinterpret_cast<void***>(eax17) = reinterpret_cast<void**>(22);
    } else {
        eax19 = a4;
        if (eax19) {
            edx20 = reinterpret_cast<void*>(reinterpret_cast<unsigned char>(esi13) - reinterpret_cast<unsigned char>(eax19));
            do {
                ecx21 = reinterpret_cast<void**>(static_cast<uint32_t>(reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(eax19))));
                *reinterpret_cast<int16_t*>(reinterpret_cast<uint32_t>(edx20) + reinterpret_cast<unsigned char>(eax19)) = *reinterpret_cast<int16_t*>(&ecx21);
                eax19 = eax19 + 2;
                if (!*reinterpret_cast<int16_t*>(&ecx21)) 
                    break;
                --edi16;
            } while (edi16);
            eax22 = reinterpret_cast<void**>(0);
            if (edi16) 
                goto addr_10008aa0_8; else 
                goto addr_10008acc_9;
        } else {
            *reinterpret_cast<void***>(esi13) = eax19;
            goto addr_10008a8f_2;
        }
    }
    addr_10008a99_11:
    fun_10002844(ecx);
    eax22 = esi18;
    addr_10008aa0_8:
    return eax22;
    addr_10008acc_9:
    *reinterpret_cast<void***>(esi13) = reinterpret_cast<void**>(0);
    eax23 = fun_10002896(ecx21, v14, v11, v9, v8, a2, a3, a4, a5, a6, a7);
    ecx = reinterpret_cast<void**>(34);
    *reinterpret_cast<void***>(eax23) = reinterpret_cast<void**>(34);
    esi18 = reinterpret_cast<void**>(34);
    goto addr_10008a99_11;
}

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

void fun_100027f2(void** ecx, int32_t a2, void** a3, void** a4, void** a5, void** a6) {
    void** esi7;

    fun_100026c9(ecx, 2, 0xc0000417, 1, esi7, __return_address());
    GetCurrentProcess();
    TerminateProcess();
    goto 0xc0000417;
}

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

    eax6 = a2;
    do {
        eax6 = eax6 + 2;
    } while (*reinterpret_cast<void***>(eax6));
    return (reinterpret_cast<int32_t>(reinterpret_cast<unsigned char>(eax6) - reinterpret_cast<unsigned char>(a2)) >> 1) - 1;
}

void** fun_10008992(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8) {
    void** v9;
    void** v10;
    void** ebp11;
    void** edx12;
    void** v13;
    void** ebx14;
    void** ebx15;
    void** v16;
    void** esi17;
    void** v18;
    void** edi19;
    void** edi20;
    void** ecx21;
    void** eax22;
    void** esi23;
    void** eax24;
    void* esi25;
    void* esi26;
    uint32_t eax27;
    void** eax28;
    void** eax29;

    v9 = reinterpret_cast<void**>(__return_address());
    v10 = ebp11;
    edx12 = a1;
    v13 = ebx14;
    ebx15 = a4;
    v16 = esi17;
    v18 = edi19;
    if (ebx15) {
        if (!edx12) 
            goto addr_100089bf_3;
    } else {
        if (!edx12) {
            if (a2 != edx12) 
                goto addr_100089bf_3; else 
                goto addr_100089ad_6;
        }
    }
    edi20 = a2;
    if (edi20) {
        if (!ebx15) {
            *reinterpret_cast<void***>(edx12) = reinterpret_cast<void**>(0);
            goto addr_100089ad_6;
        }
        ecx21 = a3;
        if (!ecx21) 
            goto addr_100089e4_11;
    } else {
        addr_100089bf_3:
        eax22 = fun_10002896(ecx21, v18, v16, v13, v10, v9, a1, a2, a3, a4, a5);
        esi23 = reinterpret_cast<void**>(22);
        *reinterpret_cast<void***>(eax22) = reinterpret_cast<void**>(22);
        goto addr_100089c9_12;
    }
    eax24 = edx12;
    if (!reinterpret_cast<int1_t>(ebx15 == 0xffffffff)) {
        esi25 = reinterpret_cast<void*>(reinterpret_cast<unsigned char>(ecx21) - reinterpret_cast<unsigned char>(edx12));
        do {
            ecx21 = reinterpret_cast<void**>(static_cast<uint32_t>(*reinterpret_cast<uint16_t*>(reinterpret_cast<uint32_t>(esi25) + reinterpret_cast<unsigned char>(eax24))));
            *reinterpret_cast<void***>(eax24) = ecx21;
            eax24 = eax24 + 2;
            if (!ecx21) 
                break;
            --edi20;
        } while (edi20 && (--ebx15, !!ebx15));
        if (!ebx15) 
            goto addr_10008a27_18;
    } else {
        esi26 = reinterpret_cast<void*>(reinterpret_cast<unsigned char>(edx12) - reinterpret_cast<unsigned char>(ecx21));
        do {
            eax27 = reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(ecx21));
            *reinterpret_cast<int16_t*>(reinterpret_cast<uint32_t>(esi26) + reinterpret_cast<unsigned char>(ecx21)) = *reinterpret_cast<int16_t*>(&eax27);
            ecx21 = ecx21 + 2;
            if (!*reinterpret_cast<int16_t*>(&eax27)) 
                break;
            --edi20;
        } while (edi20);
        goto addr_10008a08_22;
    }
    addr_10008a2c_23:
    if (edi20) {
        addr_100089ad_6:
        eax28 = reinterpret_cast<void**>(0);
    } else {
        if (!reinterpret_cast<int1_t>(ebx15 == 0xffffffff)) {
            *reinterpret_cast<void***>(edx12) = reinterpret_cast<void**>(0);
            eax29 = fun_10002896(ecx21, v18, v16, v13, v10, v9, a1, a2, a3, a4, a5);
            ecx21 = reinterpret_cast<void**>(34);
            *reinterpret_cast<void***>(eax29) = reinterpret_cast<void**>(34);
            esi23 = reinterpret_cast<void**>(34);
            goto addr_100089c9_12;
        } else {
            *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(edx12 + reinterpret_cast<unsigned char>(a2) * 2) - 2) = reinterpret_cast<void**>(0);
            eax28 = reinterpret_cast<void**>(80);
        }
    }
    addr_100089af_27:
    return eax28;
    addr_100089c9_12:
    fun_10002844(ecx21);
    eax28 = esi23;
    goto addr_100089af_27;
    addr_10008a27_18:
    ecx21 = reinterpret_cast<void**>(0);
    *reinterpret_cast<void***>(eax24) = reinterpret_cast<void**>(0);
    goto addr_10008a2c_23;
    addr_10008a08_22:
    goto addr_10008a2c_23;
    addr_100089e4_11:
    *reinterpret_cast<void***>(edx12) = reinterpret_cast<void**>(0);
    goto addr_100089bf_3;
}

void** fun_1000891d(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
    void** v8;
    void** v9;
    void** ebp10;
    void** v11;
    void** esi12;
    void** esi13;
    void** v14;
    void** edi15;
    void** edi16;
    void** eax17;
    void** esi18;
    void** edx19;
    void** eax20;
    void* edx21;
    uint32_t eax22;
    void** eax23;

    v8 = reinterpret_cast<void**>(__return_address());
    v9 = ebp10;
    v11 = esi12;
    esi13 = a2;
    v14 = edi15;
    if (!esi13 || (edi16 = a3, !edi16)) {
        addr_10008932_2:
        eax17 = fun_10002896(ecx, v14, v11, v9, v8, a2, a3, a4, a5, a6, a7);
        esi18 = reinterpret_cast<void**>(22);
        *reinterpret_cast<void***>(eax17) = reinterpret_cast<void**>(22);
    } else {
        ecx = a4;
        if (ecx) {
            edx19 = esi13;
            do {
                if (!*reinterpret_cast<void***>(edx19)) 
                    break;
                edx19 = edx19 + 2;
                --edi16;
            } while (edi16);
            if (!edi16) 
                goto addr_1000894e_8; else 
                goto addr_10008967_9;
        } else {
            addr_1000894e_8:
            *reinterpret_cast<void***>(esi13) = reinterpret_cast<void**>(0);
            goto addr_10008932_2;
        }
    }
    addr_1000893c_10:
    fun_10002844(ecx);
    eax20 = esi18;
    addr_10008943_11:
    return eax20;
    addr_10008967_9:
    edx21 = reinterpret_cast<void*>(reinterpret_cast<unsigned char>(edx19) - reinterpret_cast<unsigned char>(ecx));
    do {
        eax22 = reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(ecx));
        *reinterpret_cast<int16_t*>(reinterpret_cast<uint32_t>(edx21) + reinterpret_cast<unsigned char>(ecx)) = *reinterpret_cast<int16_t*>(&eax22);
        ecx = ecx + 2;
        if (!*reinterpret_cast<int16_t*>(&eax22)) 
            break;
        --edi16;
    } while (edi16);
    eax20 = reinterpret_cast<void**>(0);
    if (edi16) 
        goto addr_10008943_11;
    *reinterpret_cast<void***>(esi13) = reinterpret_cast<void**>(0);
    eax23 = fun_10002896(ecx, v14, v11, v9, v8, a2, a3, a4, a5, a6, a7);
    ecx = reinterpret_cast<void**>(34);
    *reinterpret_cast<void***>(eax23) = reinterpret_cast<void**>(34);
    esi18 = reinterpret_cast<void**>(34);
    goto addr_1000893c_10;
}

int32_t g1000eae4;

int32_t LoadLibraryW = 0xccf0;

void** g1000eae8;

void** g1000eaec;

void** g1000eaf4;

void** g1000eaf0;

void** fun_100087b1(void** ecx, void** a2, void** a3, uint32_t a4, void** a5, void** a6, void** a7) {
    void* ebp8;
    void** eax9;
    void** edi10;
    void** esi11;
    void** ebx12;
    void** v13;
    void** eax14;
    uint32_t v15;
    int1_t zf16;
    int32_t eax17;
    int32_t edi18;
    int32_t eax19;
    int32_t esi20;
    int32_t eax21;
    int32_t eax22;
    void** eax23;
    int32_t eax24;
    void** eax25;
    int32_t eax26;
    void** eax27;
    int32_t eax28;
    void** eax29;
    void** eax30;
    int32_t esi31;
    int1_t zf32;
    int32_t eax33;
    void** v34;
    int32_t eax35;
    int32_t eax36;
    int32_t eax37;
    unsigned char v38;
    void** eax39;
    int32_t eax40;
    uint32_t eax41;
    void** eax42;
    int32_t eax43;
    uint32_t eax44;
    int32_t eax45;
    void** eax46;

    ebp8 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    eax9 = g1000d050;
    eax14 = fun_1000350d(ecx, edi10, esi11, ebx12, v13, a2, a3);
    v15 = 0;
    zf16 = g1000eae4 == 0;
    if (zf16) {
        eax17 = reinterpret_cast<int32_t>(LoadLibraryW());
        if (!eax17) 
            goto addr_1000890c_3;
        edi18 = GetProcAddress;
        eax19 = reinterpret_cast<int32_t>(edi18(eax17, "MessageBoxW"));
        if (!eax19) 
            goto addr_1000890c_3;
        esi20 = EncodePointer;
        eax21 = reinterpret_cast<int32_t>(esi20(eax19, eax17, "MessageBoxW"));
        g1000eae4 = eax21;
        eax22 = reinterpret_cast<int32_t>(edi18(eax17, "GetActiveWindow", eax19, eax17, "MessageBoxW"));
        eax23 = reinterpret_cast<void**>(esi20(eax22, eax17, "GetActiveWindow", eax19, eax17, "MessageBoxW"));
        g1000eae8 = eax23;
        eax24 = reinterpret_cast<int32_t>(edi18(eax17, "GetLastActivePopup", eax22, eax17, "GetActiveWindow", eax19, eax17, "MessageBoxW"));
        eax25 = reinterpret_cast<void**>(esi20(eax24, eax17, "GetLastActivePopup", eax22, eax17, "GetActiveWindow", eax19, eax17, "MessageBoxW"));
        g1000eaec = eax25;
        eax26 = reinterpret_cast<int32_t>(edi18(eax17, "GetUserObjectInformationW", eax24, eax17, "GetLastActivePopup", eax22, eax17, "GetActiveWindow", eax19, eax17, "MessageBoxW"));
        eax27 = reinterpret_cast<void**>(esi20(eax26, eax17, "GetUserObjectInformationW", eax24, eax17, "GetLastActivePopup", eax22, eax17, "GetActiveWindow", eax19, eax17, "MessageBoxW"));
        g1000eaf4 = eax27;
        if (eax27) {
            eax28 = reinterpret_cast<int32_t>(edi18(eax17, "GetProcessWindowStation", eax26, eax17, "GetUserObjectInformationW", eax24, eax17, "GetLastActivePopup", eax22, eax17, "GetActiveWindow", eax19, eax17, "MessageBoxW"));
            eax29 = reinterpret_cast<void**>(esi20(eax28, eax17, "GetProcessWindowStation", eax26, eax17, "GetUserObjectInformationW", eax24, eax17, "GetLastActivePopup", eax22, eax17, "GetActiveWindow", eax19, eax17, "MessageBoxW"));
            g1000eaf0 = eax29;
        }
    }
    eax30 = g1000eaf0;
    esi31 = DecodePointer;
    if (eax30 == eax14 || ((zf32 = g1000eaf4 == eax14, zf32) || ((eax33 = reinterpret_cast<int32_t>(esi31(eax30)), v34 = g1000eaf4, eax35 = reinterpret_cast<int32_t>(esi31(v34, eax30)), eax33 == 0) || (!eax35 || (eax36 = reinterpret_cast<int32_t>(eax33(v34, eax30)), !!eax36) && ((eax37 = reinterpret_cast<int32_t>(eax35(eax36, 1, reinterpret_cast<uint32_t>(ebp8) - 16, 12, reinterpret_cast<uint32_t>(ebp8) - 36, v34, eax30)), !!eax37) && v38 & 1))))) {
        eax39 = g1000eae8;
        if (eax39 != eax14 && ((eax40 = reinterpret_cast<int32_t>(esi31(eax39)), !!eax40) && ((eax41 = reinterpret_cast<uint32_t>(eax40(eax39)), v15 = eax41, !!eax41) && ((eax42 = g1000eaec, eax42 != eax14) && (eax43 = reinterpret_cast<int32_t>(esi31(eax42, eax39)), !!eax43))))) {
            eax44 = reinterpret_cast<uint32_t>(eax43(v15, eax42, eax39));
            v15 = eax44;
        }
    } else {
        a4 = a4 | 0x200000;
    }
    eax45 = reinterpret_cast<int32_t>(esi31());
    if (!eax45) {
        addr_1000890c_3:
    } else {
        eax45(v15, a2, a3, a4);
    }
    eax46 = fun_10001cc4(reinterpret_cast<unsigned char>(eax9) ^ reinterpret_cast<uint32_t>(ebp8) ^ reinterpret_cast<uint32_t>(ebp8), ebx12);
    return eax46;
}

int32_t CreateFileW = 0xc8e8;

void fun_10008b1c(void** a1) {
    int32_t eax2;

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

struct s60 {
    signed char[20] pad20;
    void** f20;
};

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

struct s62 {
    signed char[112] pad112;
    uint32_t f112;
};

struct s63 {
    signed char[4] pad4;
    int32_t f4;
    signed char[164] pad172;
    void** f172;
};

struct s64 {
    signed char[112] pad112;
    uint32_t f112;
};

void** fun_10007e4f(void** a1, void** a2, void** a3, void** a4) {
    void*** ebp5;
    void** eax6;
    void** ecx7;
    void** esi8;
    void** ebx9;
    void** v10;
    void** v11;
    void** v12;
    void** v13;
    void** ebp14;
    struct s60* v15;
    uint32_t ecx16;
    void** v17;
    void** v18;
    uint32_t eax19;
    void** ecx20;
    int32_t eax21;
    int32_t v22;
    struct s61* v23;
    int32_t eax24;
    void** v25;
    struct s62* v26;
    struct s63* eax27;
    struct s63* v28;
    void** ecx29;
    int32_t edx30;
    int32_t v31;
    int32_t eax32;
    struct s63* v33;
    void** v34;
    struct s64* v35;
    void** v36;
    void** v37;
    void** v38;
    void** eax39;
    void** v40;
    void** v41;

    ebp5 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    if (!a2 || !a3) {
        addr_10007e77_2:
        eax6 = reinterpret_cast<void**>(0);
    } else {
        if (*reinterpret_cast<void***>(a2)) {
            ecx7 = reinterpret_cast<void**>(ebp5 + 0xfffffff0);
            fun_10001d91(ecx7, a4, esi8, ebx9, v10, v11, v12, v13, ebp14, __return_address(), a1);
            if (!v15->f20) {
                if (a1) {
                    ecx16 = reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a2));
                    *reinterpret_cast<void***>(a1) = *reinterpret_cast<void***>(&ecx16);
                    goto addr_10007e9d_7;
                }
            }
            v17 = reinterpret_cast<void**>(ebp5 + 0xfffffff0);
            v18 = reinterpret_cast<void**>(static_cast<uint32_t>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a2))));
            eax19 = fun_10005acd(ecx7, v18, v17, esi8);
            ecx20 = v17;
            if (!eax19) 
                goto addr_10007f3e_9; else 
                goto addr_10007ec1_10;
        } else {
            if (a1) {
                *reinterpret_cast<void***>(a1) = reinterpret_cast<void**>(0);
                goto addr_10007e77_2;
            }
        }
    }
    addr_10007e79_13:
    return eax6;
    addr_10007f3e_9:
    eax21 = 0;
    *reinterpret_cast<unsigned char*>(&eax21) = reinterpret_cast<uint1_t>(!!a1);
    v22 = v23->f4;
    eax24 = reinterpret_cast<int32_t>(MultiByteToWideChar(ecx20, v22, 9, a2, 1, a1, eax21));
    if (eax24) {
        addr_10007e9d_7:
        if (v25) {
            v26->f112 = v26->f112 & 0xfffffffd;
        }
    } else {
        goto addr_10007f1f_16;
    }
    eax6 = reinterpret_cast<void**>(1);
    goto addr_10007e79_13;
    addr_10007ec1_10:
    eax27 = v28;
    ecx29 = eax27->f172;
    if (reinterpret_cast<signed char>(ecx29) > reinterpret_cast<signed char>(1) && (reinterpret_cast<signed char>(a3) >= reinterpret_cast<signed char>(ecx29) && (edx30 = 0, *reinterpret_cast<unsigned char*>(&edx30) = reinterpret_cast<uint1_t>(!!a1), v31 = eax27->f4, eax32 = reinterpret_cast<int32_t>(MultiByteToWideChar(v31, 9, a2, ecx29, a1, edx30)), eax27 = v33, !!eax32)) || (ecx20 = a3, reinterpret_cast<unsigned char>(ecx20) >= reinterpret_cast<unsigned char>(eax27->f172)) && *reinterpret_cast<void***>(a2 + 1)) {
        eax6 = eax27->f172;
        if (v34) {
            v35->f112 = v35->f112 & 0xfffffffd;
            goto addr_10007e79_13;
        }
    } else {
        addr_10007f1f_16:
        eax39 = fun_10002896(ecx20, esi8, ebx9, v36, 1, v37, v38, ebp14, __return_address(), a1, a2);
        *reinterpret_cast<void***>(eax39) = reinterpret_cast<void**>(42);
        if (v40) {
            *reinterpret_cast<void***>(v41 + 0x70) = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(v41 + 0x70)) & 0xfffffffd);
        }
    }
    eax6 = reinterpret_cast<void**>(0xffffffff);
    goto addr_10007e79_13;
}

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

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

void fun_10008c2b(void** ecx);

int32_t fun_10008bbf(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10) {
    int32_t ebp11;
    int32_t eax12;
    void** esi13;
    struct s65* ebp14;
    int32_t ebp15;
    uint32_t eax16;
    int32_t ebp17;
    int32_t ebp18;
    void** eax19;

    fun_10004570(0x1000c5f8, 12, __return_address());
    *reinterpret_cast<uint32_t*>(ebp11 - 28) = 0xffffffff;
    eax12 = 0;
    esi13 = ebp14->f8;
    *reinterpret_cast<unsigned char*>(&eax12) = reinterpret_cast<uint1_t>(!!esi13);
    if (eax12) {
        if (!(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(esi13 + 12)) & 64)) {
            fun_1000578d(esi13, 0x1000c5f8, 12, __return_address(), a2, a3);
            *reinterpret_cast<uint32_t*>(ebp15 - 4) = 0;
            eax16 = fun_10008b52(esi13, esi13, 0x1000c5f8, 12, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10);
            ecx = esi13;
            *reinterpret_cast<uint32_t*>(ebp17 - 28) = eax16;
            *reinterpret_cast<int32_t*>(ebp18 - 4) = -2;
            fun_10008c2b(ecx);
        } else {
            *reinterpret_cast<void***>(esi13 + 12) = reinterpret_cast<void**>(0);
        }
    } else {
        eax19 = fun_10002896(ecx, 0x1000c5f8, 12, __return_address(), a2, a3, a4, a5, a6, a7, a8);
        *reinterpret_cast<void***>(eax19) = reinterpret_cast<void**>(22);
        fun_10002844(ecx);
    }
    fun_100045b5(ecx, 0x1000c5f8, 12, __return_address(), a2, a3);
    goto 0x1000c5f8;
}

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

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

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

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

void fun_1000819a(void** ecx);

void fun_100081c9(void** ecx);

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

uint32_t fun_100080f8(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
    void** v8;
    int32_t ebp9;
    int32_t ebp10;
    void** ecx11;
    int32_t ebp12;
    void** esi13;
    int32_t ebp14;
    int1_t less15;
    void** eax16;
    void*** eax17;
    void** v18;
    int32_t ebp19;
    void** eax20;
    struct s66* ebp21;
    struct s67* ebp22;
    void** v23;
    uint32_t eax24;
    int32_t ebp25;
    int32_t ebp26;
    void** v27;
    uint32_t eax28;
    int32_t ebp29;
    int32_t ebp30;
    int32_t ebp31;
    int32_t ebp32;
    struct s68* ebp33;

    v8 = reinterpret_cast<void**>(__return_address());
    fun_10004570(0x1000c5d0, 20, v8);
    *reinterpret_cast<void***>(ebp9 - 28) = reinterpret_cast<void**>(0);
    *reinterpret_cast<void***>(ebp10 - 36) = reinterpret_cast<void**>(0);
    fun_10006df1(ecx, 1, 0x1000c5d0, 20, v8, a2, a3, a4, a5, a6, a7);
    ecx11 = reinterpret_cast<void**>(1);
    *reinterpret_cast<void***>(ebp12 - 4) = reinterpret_cast<void**>(0);
    esi13 = reinterpret_cast<void**>(0);
    while (*reinterpret_cast<void***>(ebp14 - 32) = esi13, less15 = reinterpret_cast<signed char>(esi13) < reinterpret_cast<signed char>(g1000fb20), less15) {
        eax16 = g1000eb04;
        eax17 = reinterpret_cast<void***>(eax16 + reinterpret_cast<unsigned char>(esi13) * 4);
        if (*eax17 && reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(*eax17 + 12)) & 0x83) {
            v18 = *eax17;
            fun_100057ce(ecx11, esi13, v18, 0x1000c5d0, 20, v8, a2, a3);
            *reinterpret_cast<int32_t*>(ebp19 - 4) = 1;
            eax20 = g1000eb04;
            ecx11 = *reinterpret_cast<void***>(*reinterpret_cast<void***>(eax20 + reinterpret_cast<unsigned char>(esi13) * 4) + 12);
            if (*reinterpret_cast<unsigned char*>(&ecx11) & 0x83) {
                if (ebp21->f8 != 1) {
                    if (!ebp22->f8 && (*reinterpret_cast<unsigned char*>(&ecx11) & 2 && (v23 = *reinterpret_cast<void***>(eax20 + reinterpret_cast<unsigned char>(esi13) * 4), eax24 = fun_100080b0(ecx11, v23, 0x1000c5d0, 20, v8), ecx11 = v23, eax24 == 0xffffffff))) {
                        *reinterpret_cast<uint32_t*>(ebp25 - 36) = *reinterpret_cast<uint32_t*>(ebp26 - 36) | eax24;
                    }
                } else {
                    v27 = *reinterpret_cast<void***>(eax20 + reinterpret_cast<unsigned char>(esi13) * 4);
                    eax28 = fun_100080b0(ecx11, v27, 0x1000c5d0, 20, v8);
                    ecx11 = v27;
                    if (eax28 != 0xffffffff) {
                        *reinterpret_cast<int32_t*>(ebp29 - 28) = *reinterpret_cast<int32_t*>(ebp30 - 28) + 1;
                    }
                }
            }
            *reinterpret_cast<void***>(ebp31 - 4) = reinterpret_cast<void**>(0);
            fun_1000819a(ecx11);
        }
        ++esi13;
    }
    *reinterpret_cast<int32_t*>(ebp32 - 4) = -2;
    fun_100081c9(ecx11);
    if (ebp33->f8 != 1) {
    }
    fun_100045b5(ecx11, 0x1000c5d0, 20, v8, a2, a3);
    goto 0x1000c5d0;
}

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

int32_t FlushFileBuffers = 0xcd5e;

void fun_10008d04(void** ecx);

int32_t fun_10008c33(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8) {
    void** ebx9;
    struct s69* ebp10;
    int1_t cf11;
    void** edi12;
    uint32_t esi13;
    void** eax14;
    int32_t ebp15;
    void** eax16;
    int32_t ebp17;
    void** eax18;
    int32_t eax19;
    int32_t ebp20;
    int32_t eax21;
    int32_t ebp22;
    int32_t ebp23;
    void** eax24;
    int32_t ebp25;
    void** eax26;
    int32_t ebp27;

    fun_10004570(0x1000c618, 16, __return_address());
    ebx9 = ebp10->f8;
    if (!reinterpret_cast<int1_t>(ebx9 == 0xfffffffe)) {
        if (reinterpret_cast<signed char>(ebx9) < reinterpret_cast<signed char>(0) || ((cf11 = reinterpret_cast<unsigned char>(ebx9) < reinterpret_cast<unsigned char>(g1000fb2c), !cf11) || (edi12 = reinterpret_cast<void**>((reinterpret_cast<signed char>(ebx9) >> 5) * 4 + 0x1000fb40), esi13 = (reinterpret_cast<unsigned char>(ebx9) & 31) << 6, (reinterpret_cast<uint32_t>(static_cast<int32_t>(*reinterpret_cast<signed char*>(esi13 + reinterpret_cast<int32_t>(*edi12) + 4))) & 1) == 0))) {
            eax14 = fun_10002896(ecx, 0x1000c618, 16, __return_address(), a2, a3, a4, a5, a6, a7, a8);
            *reinterpret_cast<void***>(eax14) = reinterpret_cast<void**>(9);
            fun_10002844(ecx);
        } else {
            fun_10007d47(ecx, ebx9, 0x1000c618, 16, __return_address(), a2, a3);
            ecx = ebx9;
            *reinterpret_cast<uint32_t*>(ebp15 - 4) = 0;
            if (!(*reinterpret_cast<unsigned char*>(esi13 + reinterpret_cast<int32_t>(*edi12) + 4) & 1)) {
                addr_10008cdd_5:
                eax16 = fun_10002896(ecx, 0x1000c618, 16, __return_address(), a2, a3, a4, a5, a6, a7, a8);
                *reinterpret_cast<void***>(eax16) = reinterpret_cast<void**>(9);
                *reinterpret_cast<uint32_t*>(ebp17 - 28) = 0xffffffff;
                goto addr_10008cec_6;
            } else {
                eax18 = fun_10007cde(ecx, ebx9, 0x1000c618, 16, __return_address(), a2, a3, a4, a5);
                ecx = ebx9;
                eax19 = reinterpret_cast<int32_t>(FlushFileBuffers(ecx, eax18));
                if (eax19) {
                    *reinterpret_cast<uint32_t*>(ebp20 - 28) = 0;
                } else {
                    eax21 = reinterpret_cast<int32_t>(GetLastError(ecx, eax18));
                    *reinterpret_cast<int32_t*>(ebp22 - 28) = eax21;
                }
                if (!*reinterpret_cast<int32_t*>(ebp23 - 28)) 
                    goto addr_10008cec_6; else 
                    goto addr_10008cd3_11;
            }
        }
    } else {
        eax24 = fun_10002896(ecx, 0x1000c618, 16, __return_address(), a2, a3, a4, a5, a6, a7, a8);
        *reinterpret_cast<void***>(eax24) = reinterpret_cast<void**>(9);
    }
    addr_10008cfb_14:
    fun_100045b5(ecx, 0x1000c618, 16, __return_address(), a2, a3);
    goto 0x1000c618;
    addr_10008cec_6:
    *reinterpret_cast<int32_t*>(ebp25 - 4) = -2;
    fun_10008d04(ecx);
    goto addr_10008cfb_14;
    addr_10008cd3_11:
    eax26 = fun_100028a9(ecx, eax18, 0x1000c618, 16, __return_address(), a2, a3, a4, a5, a6);
    ecx = *reinterpret_cast<void***>(ebp27 - 28);
    *reinterpret_cast<void***>(eax26) = ecx;
    goto addr_10008cdd_5;
}

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

    if (reinterpret_cast<signed char>(a2) >= reinterpret_cast<signed char>(20)) {
        EnterCriticalSection();
        goto ebp9;
    } else {
        fun_10006df1(ecx, a2 + 16, ebp9, __return_address(), a2, a3, a4, a5, a6, a7, a8);
        *reinterpret_cast<void***>(a3 + 12) = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a3 + 12)) | 0x8000);
        return;
    }
}

uint32_t fun_10008048(void** a1);

uint32_t fun_100080b0(void** ecx, void** a2, void** a3, void** a4, void** a5) {
    uint32_t eax6;
    uint32_t eax7;
    void** esi8;
    void** ebp9;
    void** eax10;
    int32_t eax11;
    uint32_t eax12;

    if (a2) {
        eax6 = fun_10008048(a2);
        if (!eax6) {
            if (!(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a2 + 12)) & 0x4000)) {
                eax7 = 0;
            } else {
                eax10 = fun_1000586b(a2, a2, esi8, ebp9, __return_address(), a2, a3, a4, a5);
                eax11 = fun_10008c33(a2, eax10, a2, esi8, ebp9, __return_address(), a2, a3);
                eax12 = reinterpret_cast<uint32_t>(-eax11);
                eax7 = eax12 - (eax12 + reinterpret_cast<uint1_t>(eax12 < eax12 + reinterpret_cast<uint1_t>(!!eax11)));
            }
        } else {
            eax7 = 0xffffffff;
        }
    } else {
        eax7 = fun_100080f8(ecx, a2, esi8, ebp9, __return_address(), a2, a3);
    }
    return eax7;
}

void fun_100081c9(void** ecx) {
    fun_10006d18(ecx, 1);
    return;
}

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

int32_t fun_10008300(struct s70* a1, int32_t a2);

void fun_10008345(void** a1, void** a2) {
    struct s56* v3;
    struct s56* edi4;
    void** v5;
    void** ebp6;
    void** v7;
    void*** esp8;
    void** v9;
    void** eax10;
    void** v11;
    void** ebx12;
    void*** esi13;
    void** ecx14;

    v3 = edi4;
    v5 = ebp6;
    v7 = a1;
    esp8 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4);
    v9 = g0;
    eax10 = g1000d050;
    v11 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax10) ^ reinterpret_cast<uint32_t>(esp8));
    g0 = reinterpret_cast<void**>(esp8 - 4 + 4);
    while ((ebx12 = *reinterpret_cast<void***>(a1 + 8), *reinterpret_cast<void***>(a1 + 12) != 0xffffffff) && (a2 == 0xffffffff || reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a1 + 12)) > reinterpret_cast<unsigned char>(a2))) {
        esi13 = reinterpret_cast<void***>(*reinterpret_cast<void***>(a1 + 12) + reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a1 + 12)) * 2);
        ecx14 = *reinterpret_cast<void***>(ebx12 + reinterpret_cast<uint32_t>(esi13) * 4);
        *reinterpret_cast<void***>(a1 + 12) = ecx14;
        if (!*reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(ebx12 + reinterpret_cast<uint32_t>(esi13) * 4) + 4)) {
            fun_100083f5(ecx14, 0x101, v11, v9, fun_10008300, ecx14, v7, v5, v3);
            fun_10008414(ecx14, v11, v9, fun_10008300, ecx14, v7, v5, v3);
        }
    }
    g0 = v9;
    return;
}

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

void** g1000e49c;

void** g1000e494;

void** g1000e498;

void** fun_10007659(void** a1);

void** g1000e490;

void* g1000a688 = reinterpret_cast<void*>(3);

void* g1000a68c = reinterpret_cast<void*>(9);

void fun_10007804(void** ecx);

void fun_1000769d(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
    void** v8;
    void** edi9;
    int32_t ebp10;
    int32_t ebp11;
    void** ebx12;
    struct s71* ebp13;
    uint32_t eax14;
    void*** esi15;
    void** eax16;
    uint32_t eax17;
    void** eax18;
    void** eax19;
    int32_t ebp20;
    void** v21;
    void** eax22;
    void** ecx23;
    void** eax24;
    void* eax25;
    void* eax26;
    void* eax27;
    int32_t ebp28;
    int32_t ebp29;
    void** eax30;
    int32_t ebp31;
    int32_t ebp32;
    int32_t ebp33;
    int32_t ebp34;
    int32_t ebp35;
    int32_t ebp36;
    void** eax37;
    void* ecx38;
    int32_t ebp39;
    void* ecx40;
    void** tmp32_41;
    int32_t ebp42;
    int32_t ebp43;
    int32_t ebp44;
    int32_t ebp45;
    int32_t ebp46;
    void** v47;
    int32_t ebp48;
    int32_t ebp49;
    int32_t ebp50;
    int32_t ebp51;

    v8 = reinterpret_cast<void**>(__return_address());
    fun_10004570(0x1000c550, 32, v8);
    edi9 = reinterpret_cast<void**>(0);
    *reinterpret_cast<void***>(ebp10 - 28) = reinterpret_cast<void**>(0);
    *reinterpret_cast<void***>(ebp11 - 40) = reinterpret_cast<void**>(0);
    ebx12 = ebp13->f8;
    if (reinterpret_cast<signed char>(ebx12) > reinterpret_cast<signed char>(11)) {
        eax14 = reinterpret_cast<uint32_t>(ebx12 - 15);
        if (!eax14) {
            esi15 = reinterpret_cast<void***>(0x1000e49c);
            eax16 = g1000e49c;
        } else {
            eax17 = eax14 - 6;
            if (!eax17) {
                esi15 = reinterpret_cast<void***>(0x1000e494);
                eax16 = g1000e494;
            } else {
                if (!(eax17 - 1)) {
                    addr_10007725_7:
                    esi15 = reinterpret_cast<void***>(0x1000e498);
                    eax16 = g1000e498;
                } else {
                    addr_10007713_8:
                    eax18 = fun_10002896(2, 0x1000c550, 32, v8, a1, a2, a3, a4, a5, a6, a7);
                    *reinterpret_cast<void***>(eax18) = reinterpret_cast<void**>(22);
                    fun_10002844(2);
                    goto addr_100076de_9;
                }
            }
        }
    } else {
        if (ebx12 == 11) {
            addr_100076d0_11:
            eax19 = fun_10003644(2, 0x1000c550, 32, v8, a1, a2, a3, a4, a5, a6, a7);
            edi9 = eax19;
            *reinterpret_cast<void***>(ebp20 - 40) = edi9;
            if (edi9) {
                v21 = *reinterpret_cast<void***>(edi9 + 92);
                eax22 = fun_10007659(v21);
                ecx23 = v21;
                esi15 = reinterpret_cast<void***>(eax22 + 8);
                eax24 = *esi15;
                goto addr_10007755_13;
            } else {
                addr_100076de_9:
                goto addr_1000783a_14;
            }
        } else {
            ecx23 = reinterpret_cast<void**>(2);
            eax25 = reinterpret_cast<void*>(reinterpret_cast<unsigned char>(ebx12) - reinterpret_cast<unsigned char>(2));
            if (!eax25) {
                esi15 = reinterpret_cast<void***>(0x1000e490);
                eax16 = g1000e490;
            } else {
                eax26 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(eax25) - reinterpret_cast<unsigned char>(2));
                if (eax26) {
                    eax27 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(eax26) - reinterpret_cast<unsigned char>(2));
                    if (!eax27) 
                        goto addr_10007725_7;
                    if (reinterpret_cast<uint32_t>(eax27) - reinterpret_cast<unsigned char>(2)) 
                        goto addr_10007713_8; else 
                        goto addr_100076d0_11;
                }
            }
        }
    }
    *reinterpret_cast<int32_t*>(ebp28 - 28) = 1;
    eax24 = reinterpret_cast<void**>(DecodePointer(eax16));
    addr_10007755_13:
    *reinterpret_cast<void***>(ebp29 - 32) = eax24;
    eax30 = reinterpret_cast<void**>(0);
    if (*reinterpret_cast<int32_t*>(ebp31 - 32) == 1) {
        addr_1000783a_14:
        fun_100045b5(ecx23, 0x1000c550, 32, v8, a1, a2);
        goto 0x1000c550;
    } else {
        if (!*reinterpret_cast<void***>(ebp32 - 32)) {
            eax30 = fun_10003e4a(ecx23, 3, 0x1000c550, 32, v8);
        }
        if (*reinterpret_cast<void***>(ebp33 - 28) != eax30) {
            fun_10006df1(ecx23, eax30, 0x1000c550, 32, v8, a1, a2, a3, a4, a5, a6);
            ecx23 = eax30;
        }
        *reinterpret_cast<void***>(ebp34 - 4) = reinterpret_cast<void**>(0);
        if (ebx12 == 8) 
            goto addr_10007790_26;
        if (ebx12 == 11) 
            goto addr_10007790_26;
        if (!reinterpret_cast<int1_t>(ebx12 == 4)) 
            goto addr_100077ab_29;
    }
    addr_10007790_26:
    ecx23 = *reinterpret_cast<void***>(edi9 + 96);
    *reinterpret_cast<void***>(ebp35 - 44) = ecx23;
    *reinterpret_cast<void***>(edi9 + 96) = reinterpret_cast<void**>(0);
    if (!reinterpret_cast<int1_t>(ebx12 == 8)) 
        goto addr_100077dc_30;
    ecx23 = *reinterpret_cast<void***>(edi9 + 100);
    *reinterpret_cast<void***>(ebp36 - 48) = ecx23;
    *reinterpret_cast<void***>(edi9 + 100) = reinterpret_cast<void**>(0x8c);
    addr_100077ab_29:
    if (!reinterpret_cast<int1_t>(ebx12 == 8)) {
        addr_100077dc_30:
        eax37 = fun_1000350d(ecx23, 0x1000c550, 32, v8, a1, a2, a3);
        *esi15 = eax37;
    } else {
        ecx38 = g1000a688;
        *reinterpret_cast<void**>(ebp39 - 36) = ecx38;
        while (ecx40 = g1000a68c, tmp32_41 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(ecx40) + reinterpret_cast<uint32_t>(g1000a688)), ecx23 = tmp32_41, reinterpret_cast<signed char>(*reinterpret_cast<void***>(ebp42 - 36)) < reinterpret_cast<signed char>(ecx23)) {
            *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(*reinterpret_cast<void***>(edi9 + 92) + *reinterpret_cast<int32_t*>(ebp43 - 36) * 12) + 8) = reinterpret_cast<void**>(0);
            *reinterpret_cast<int32_t*>(ebp44 - 36) = *reinterpret_cast<int32_t*>(ebp45 - 36) + 1;
        }
    }
    *reinterpret_cast<int32_t*>(ebp46 - 4) = -2;
    fun_10007804(ecx23);
    if (!reinterpret_cast<int1_t>(ebx12 == 8)) {
        v47 = ebx12;
        *reinterpret_cast<int32_t*>(ebp48 - 32)(ecx23);
    } else {
        v47 = *reinterpret_cast<void***>(edi9 + 100);
        *reinterpret_cast<int32_t*>(ebp49 - 32)(ecx23);
    }
    ecx23 = v47;
    if ((ebx12 == 8 || (ebx12 == 11 || reinterpret_cast<int1_t>(ebx12 == 4))) && (*reinterpret_cast<void***>(edi9 + 96) = *reinterpret_cast<void***>(ebp50 - 44), reinterpret_cast<int1_t>(ebx12 == 8))) {
        *reinterpret_cast<void***>(edi9 + 100) = *reinterpret_cast<void***>(ebp51 - 48);
    }
    goto addr_1000783a_14;
}

void** fun_100026c9(void** ecx, void** a2, int32_t a3, void** a4, void** a5, void** a6) {
    void* ebp7;
    void** eax8;
    void** edi9;
    void** ebx10;
    void** v11;
    void** v12;
    void** v13;
    void** v14;
    void** v15;
    int32_t eax16;
    int32_t eax17;
    void** ecx18;
    void** eax19;

    ebp7 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    eax8 = g1000d050;
    if (a2 != 0xffffffff) {
        fun_10004ccf(ecx);
        ecx = a2;
    }
    fun_10005bc0(ecx, reinterpret_cast<uint32_t>(ebp7) + 0xfffffce4, 0, 76, edi9, ebx10, v11, v12, 0, v13, v14, v15);
    eax16 = reinterpret_cast<int32_t>(IsDebuggerPresent(edi9, ebx10, reinterpret_cast<uint32_t>(ebp7) + 0xfffffce0, reinterpret_cast<uint32_t>(ebp7) + 0xfffffd30, a3, a4));
    SetUnhandledExceptionFilter();
    eax17 = reinterpret_cast<int32_t>(UnhandledExceptionFilter());
    if (!eax17 && (!eax16 && a2 != 0xffffffff)) {
        fun_10004ccf(a4);
    }
    ecx18 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax8) ^ reinterpret_cast<uint32_t>(ebp7) ^ reinterpret_cast<uint32_t>(ebp7));
    eax19 = fun_10001cc4(ecx18, edi9, ecx18, edi9);
    return eax19;
}

uint32_t fun_10008048(void** a1) {
    void** ecx2;
    uint32_t ebx3;
    void** eax4;
    void** edi5;
    void** edi6;
    void** esi7;
    void** ebx8;
    void** ebp9;
    void** eax10;
    void** eax11;
    void** eax12;
    void** eax13;

    ecx2 = *reinterpret_cast<void***>(a1 + 12);
    *reinterpret_cast<unsigned char*>(&ecx2) = reinterpret_cast<unsigned char>(*reinterpret_cast<unsigned char*>(&ecx2) & 3);
    ebx3 = 0;
    if (*reinterpret_cast<unsigned char*>(&ecx2) == 2 && reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a1 + 12)) & 0x108) {
        eax4 = *reinterpret_cast<void***>(a1 + 8);
        edi5 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a1)) - reinterpret_cast<unsigned char>(eax4));
        if (!(reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(edi5) < reinterpret_cast<signed char>(0)) | reinterpret_cast<uint1_t>(edi5 == 0))) {
            eax10 = fun_1000586b(ecx2, a1, eax4, edi5, edi6, esi7, ebx8, ebp9, __return_address());
            eax11 = fun_10005543(a1, eax10, eax4, edi5, edi6, esi7, ebx8, ebp9);
            if (eax11 != edi5) {
                *reinterpret_cast<void***>(a1 + 12) = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a1 + 12)) | 32);
                ebx3 = 0xffffffff;
            } else {
                eax12 = *reinterpret_cast<void***>(a1 + 12);
                if (*reinterpret_cast<signed char*>(&eax12) < 0) {
                    *reinterpret_cast<void***>(a1 + 12) = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax12) & 0xfffffffd);
                }
            }
        }
    }
    eax13 = *reinterpret_cast<void***>(a1 + 8);
    *reinterpret_cast<void***>(a1 + 4) = reinterpret_cast<void**>(0);
    *reinterpret_cast<void***>(a1) = eax13;
    return ebx3;
}

void fun_10008f6f(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15) {
    void** eax16;
    void** v17;
    void** esi18;
    void** ebp19;

    eax16 = *reinterpret_cast<void***>(a2 + 12);
    if (*reinterpret_cast<unsigned char*>(&eax16) & 0x83 && *reinterpret_cast<unsigned char*>(&eax16) & 8) {
        v17 = *reinterpret_cast<void***>(a2 + 8);
        fun_10002416(ecx, v17, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
        *reinterpret_cast<void***>(a2 + 12) = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a2 + 12)) & 0xfffffbf7);
        *reinterpret_cast<void***>(a2) = reinterpret_cast<void**>(0);
        *reinterpret_cast<void***>(a2 + 8) = reinterpret_cast<void**>(0);
        *reinterpret_cast<void***>(a2 + 4) = reinterpret_cast<void**>(0);
    }
    return;
}

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

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

void fun_10008f67(void** ecx);

int32_t fun_10008eab(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8) {
    void** ebx9;
    struct s72* ebp10;
    int1_t cf11;
    void** edi12;
    uint32_t esi13;
    void** eax14;
    void** eax15;
    int32_t ebp16;
    void** eax17;
    int32_t ebp18;
    uint32_t eax19;
    int32_t ebp20;
    int32_t ebp21;
    void** eax22;
    void** eax23;

    fun_10004570(0x1000c638, 16, __return_address());
    ebx9 = ebp10->f8;
    if (!reinterpret_cast<int1_t>(ebx9 == 0xfffffffe)) {
        if (reinterpret_cast<signed char>(ebx9) < reinterpret_cast<signed char>(0) || ((cf11 = reinterpret_cast<unsigned char>(ebx9) < reinterpret_cast<unsigned char>(g1000fb2c), !cf11) || (edi12 = reinterpret_cast<void**>((reinterpret_cast<signed char>(ebx9) >> 5) * 4 + 0x1000fb40), esi13 = (reinterpret_cast<unsigned char>(ebx9) & 31) << 6, (reinterpret_cast<uint32_t>(static_cast<int32_t>(*reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(*edi12) + esi13 + 4))) & 1) == 0))) {
            eax14 = fun_100028a9(ecx, 0x1000c638, 16, __return_address(), a2, a3, a4, a5, a6, a7);
            *reinterpret_cast<void***>(eax14) = reinterpret_cast<void**>(0);
            eax15 = fun_10002896(ecx, 0x1000c638, 16, __return_address(), a2, a3, a4, a5, a6, a7, a8);
            *reinterpret_cast<void***>(eax15) = reinterpret_cast<void**>(9);
            fun_10002844(ecx);
        } else {
            fun_10007d47(ecx, ebx9, 0x1000c638, 16, __return_address(), a2, a3);
            ecx = ebx9;
            *reinterpret_cast<uint32_t*>(ebp16 - 4) = 0;
            if (!(*reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(*edi12) + esi13 + 4) & 1)) {
                eax17 = fun_10002896(ecx, 0x1000c638, 16, __return_address(), a2, a3, a4, a5, a6, a7, a8);
                *reinterpret_cast<void***>(eax17) = reinterpret_cast<void**>(9);
                *reinterpret_cast<uint32_t*>(ebp18 - 28) = 0xffffffff;
            } else {
                eax19 = fun_10008e0f(ecx, ebx9, 0x1000c638, 16, __return_address());
                ecx = ebx9;
                *reinterpret_cast<uint32_t*>(ebp20 - 28) = eax19;
            }
            *reinterpret_cast<int32_t*>(ebp21 - 4) = -2;
            fun_10008f67(ecx);
            goto addr_10008f5e_8;
        }
    } else {
        eax22 = fun_100028a9(ecx, 0x1000c638, 16, __return_address(), a2, a3, a4, a5, a6, a7);
        *reinterpret_cast<void***>(eax22) = reinterpret_cast<void**>(0);
        eax23 = fun_10002896(ecx, 0x1000c638, 16, __return_address(), a2, a3, a4, a5, a6, a7, a8);
        *reinterpret_cast<void***>(eax23) = reinterpret_cast<void**>(9);
    }
    addr_10008f5e_8:
    fun_100045b5(ecx, 0x1000c638, 16, __return_address(), a2, a3);
    goto 0x1000c638;
}

void** fun_10007cde(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9) {
    int1_t cf10;
    void* eax11;
    void** ebp12;
    void** eax13;
    void** eax14;
    void** eax15;
    void** eax16;

    if (!reinterpret_cast<int1_t>(a2 == 0xfffffffe)) {
        if (reinterpret_cast<signed char>(a2) < reinterpret_cast<signed char>(0) || ((cf10 = reinterpret_cast<unsigned char>(a2) < reinterpret_cast<unsigned char>(g1000fb2c), !cf10) || (ecx = *reinterpret_cast<void***>((reinterpret_cast<signed char>(a2) >> 5) * 4 + 0x1000fb40), eax11 = reinterpret_cast<void*>((reinterpret_cast<unsigned char>(a2) & 31) << 6), (*reinterpret_cast<unsigned char*>(reinterpret_cast<uint32_t>(eax11) + reinterpret_cast<unsigned char>(ecx) + 4) & 1) == 0))) {
            eax13 = fun_100028a9(ecx, ebp12, __return_address(), a2, a3, a4, a5, a6, a7, a8);
            *reinterpret_cast<void***>(eax13) = reinterpret_cast<void**>(0);
            eax14 = fun_10002896(ecx, ebp12, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
            *reinterpret_cast<void***>(eax14) = reinterpret_cast<void**>(9);
            fun_10002844(ecx);
        } else {
            return *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(eax11) + reinterpret_cast<unsigned char>(ecx));
        }
    } else {
        eax15 = fun_100028a9(ecx, ebp12, __return_address(), a2, a3, a4, a5, a6, a7, a8);
        *reinterpret_cast<void***>(eax15) = reinterpret_cast<void**>(0);
        eax16 = fun_10002896(ecx, ebp12, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
        *reinterpret_cast<void***>(eax16) = reinterpret_cast<void**>(9);
    }
    return 0xffffffff;
}

int32_t CloseHandle = 0xc906;

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

uint32_t fun_10008e0f(void** ecx, void** a2, void** a3, void** a4, void** a5) {
    void** edi6;
    void** esi7;
    void** ebp8;
    void** eax9;
    void** ecx10;
    void** eax11;
    void** eax12;
    void** eax13;
    void** eax14;
    int32_t eax15;
    void** edi16;
    void** eax17;
    uint32_t eax18;

    eax9 = fun_10007cde(ecx, a2, edi6, esi7, ebp8, __return_address(), a2, a3, a4);
    ecx10 = a2;
    if (eax9 == 0xffffffff || (((eax11 = g1000fb40, reinterpret_cast<int1_t>(a2 == 1)) && reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(eax11 + 0x84)) & 1 || reinterpret_cast<int1_t>(a2 == 2) && reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(eax11 + 68)) & 1) && (eax12 = fun_10007cde(ecx10, 2, edi6, esi7, ebp8, __return_address(), a2, a3, a4), eax13 = fun_10007cde(ecx10, 1, 2, edi6, esi7, ebp8, __return_address(), a2, a3), ecx10 = reinterpret_cast<void**>(2), eax13 == eax12) || (eax14 = fun_10007cde(ecx10, a2, edi6, esi7, ebp8, __return_address(), a2, a3, a4), ecx10 = a2, eax15 = reinterpret_cast<int32_t>(CloseHandle(ecx10, eax14)), !!eax15))) {
        edi16 = reinterpret_cast<void**>(0);
    } else {
        eax17 = reinterpret_cast<void**>(GetLastError(ecx10, eax14));
        edi16 = eax17;
    }
    fun_10007c58(ecx10, a2, edi6, esi7, ebp8, __return_address());
    *reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(*reinterpret_cast<void**>((reinterpret_cast<signed char>(a2) >> 5) * 4 + 0x1000fb40)) + ((reinterpret_cast<unsigned char>(a2) & 31) << 6) + 4) = 0;
    if (!edi16) {
        eax18 = 0;
    } else {
        fun_100028bc(a2, edi16, edi6, esi7, ebp8, __return_address(), a2, a3);
        eax18 = 0xffffffff;
    }
    return eax18;
}

void fun_10001d86(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15) {
    void** v16;
    void** eax17;
    void** esi18;
    void** ebp19;
    void** eax20;
    void** eax21;
    void** eax22;

    if (a2 && (v16 = g1000e2e8, eax17 = reinterpret_cast<void**>(HeapFree(ecx, v16, 0, a2)), !eax17)) {
        eax20 = fun_10002896(ecx, esi18, v16, 0, a2, ebp19, __return_address(), a2, a3, a4, a5);
        eax21 = reinterpret_cast<void**>(GetLastError(ecx));
        eax22 = fun_10002854(ecx, eax21, esi18, v16, 0, a2);
        *reinterpret_cast<void***>(eax20) = eax22;
    }
    return;
}

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

void** fun_10005ccf(void** a1, void** a2, void** a3, void*** a4);

void** fun_100029a9(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9) {
    void** ebp10;
    void** eax11;
    void** esi12;
    void** eax13;
    void** eax14;
    void** eax15;

    if (!a4) {
        eax11 = fun_10002896(ecx, ebp10, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
        *reinterpret_cast<void***>(eax11) = reinterpret_cast<void**>(22);
        fun_10002844(ecx);
        return 0xffffffff;
    }
    if (!a2 || reinterpret_cast<unsigned char>(a3) <= reinterpret_cast<unsigned char>(0)) {
        eax13 = fun_10002896(ecx, esi12, ebp10, __return_address(), a2, a3, a4, a5, a6, a7, a8);
        *reinterpret_cast<void***>(eax13) = reinterpret_cast<void**>(22);
    } else {
        eax14 = fun_100028df(fun_10005ccf, a2, a3, a4, a5, a6);
        if (reinterpret_cast<signed char>(eax14) < reinterpret_cast<signed char>(0)) {
            *reinterpret_cast<void***>(a2) = reinterpret_cast<void**>(0);
        }
        if (!reinterpret_cast<int1_t>(eax14 == 0xfffffffe)) 
            goto addr_10002a1d_8; else 
            goto addr_10002a0a_9;
    }
    addr_10002a15_10:
    fun_10002844(ecx);
    eax14 = reinterpret_cast<void**>(0xffffffff);
    addr_10002a1d_8:
    return eax14;
    addr_10002a0a_9:
    eax15 = fun_10002896(ecx, esi12, ebp10, __return_address(), a2, a3, a4, a5, a6, a7, a8);
    *reinterpret_cast<void***>(eax15) = reinterpret_cast<void**>(34);
    goto addr_10002a15_10;
}

struct s73 {
    signed char[4] pad4;
    int32_t f4;
    signed char[12] pad20;
    void** f20;
};

struct s74 {
    signed char[4] pad4;
    int32_t f4;
    signed char[12] pad20;
    void** f20;
    signed char[151] pad172;
    int32_t f172;
};

struct s75 {
    signed char[112] pad112;
    uint32_t f112;
};

struct s76 {
    signed char[112] pad112;
    uint32_t f112;
};

void** fun_10001e18(void** ecx, void** a2, void** a3, void** a4, void** a5) {
    void* ebp6;
    void** eax7;
    uint32_t v8;
    void** v9;
    void** ebx10;
    void** v11;
    void** esi12;
    void** esi13;
    void** v14;
    void** edi15;
    void** v16;
    void** ecx17;
    void** v18;
    void** v19;
    void** v20;
    void** v21;
    void** v22;
    struct s73* v23;
    int32_t v24;
    void** eax25;
    void** edx26;
    struct s74* edi27;
    struct s74* v28;
    void* v29;
    void** v30;
    void** v31;
    void** v32;
    int32_t v33;
    void** v34;
    int32_t eax35;
    void** v36;
    void** v37;
    void** v38;
    void** v39;
    void** v40;
    void** eax41;
    signed char v42;
    void** v43;
    int32_t v44;
    void** eax45;
    void** eax46;
    void** v47;
    void** v48;
    void** v49;
    void** v50;
    void** v51;
    void** v52;
    void** eax53;
    signed char v54;
    struct s75* v55;
    void** eax56;
    signed char v57;
    struct s76* v58;
    int32_t v59;
    int32_t v60;
    void** eax61;
    void** eax62;
    signed char cl63;

    ebp6 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    eax7 = g1000d050;
    v8 = reinterpret_cast<unsigned char>(eax7) ^ reinterpret_cast<uint32_t>(ebp6);
    v9 = ebx10;
    v11 = esi12;
    esi13 = a3;
    v14 = edi15;
    v16 = a2;
    if (!a2 || a4) {
        if (esi13) {
            ecx17 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp6) + 0xffffffe0);
            fun_10001d91(ecx17, a5, v14, v11, v9, v18, v19, v16, v20, v21, v22);
            if (!a2) {
                if (v23->f20) {
                    ecx17 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp6) + 0xfffffff0);
                    v24 = v23->f4;
                    eax25 = reinterpret_cast<void**>(WideCharToMultiByte(v24, 0, esi13, 0xff, 0, 0, 0, ecx17));
                    if (eax25) 
                        goto addr_10001f44_6; else 
                        goto addr_10002056_7;
                } else {
                    ecx17 = reinterpret_cast<void**>(static_cast<uint32_t>(reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(esi13))));
                    edx26 = esi13;
                    while (ecx17) {
                        if (reinterpret_cast<unsigned char>(ecx17) > reinterpret_cast<unsigned char>(0xff)) 
                            goto addr_10002056_7;
                        edx26 = edx26 + 2;
                        ecx17 = reinterpret_cast<void**>(static_cast<uint32_t>(reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(edx26))));
                    }
                }
            } else {
                edi27 = v28;
                if (edi27->f20) {
                    if (edi27->f172 != 1) {
                        v29 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ebp6) + 0xfffffff0);
                        v30 = a4;
                        v31 = v16;
                        v32 = esi13;
                        v33 = edi27->f4;
                        eax25 = reinterpret_cast<void**>(WideCharToMultiByte(ecx17, v33, 0, v32, 0xff, v31, v30, 0, v29));
                        v34 = eax25;
                        if (!eax25) {
                            if (0) 
                                goto addr_10002056_7;
                            eax35 = reinterpret_cast<int32_t>(GetLastError(ecx17, v33, 0, v32, 0xff, v31, v30, 0, v29));
                            if (eax35 != 0x7a) 
                                goto addr_10002056_7;
                            if (reinterpret_cast<unsigned char>(a4) <= reinterpret_cast<unsigned char>(0)) 
                                goto addr_10001ffd_19; else 
                                goto addr_10001f74_20;
                        } else {
                            addr_10001f44_6:
                            if (0) {
                                addr_10002056_7:
                                eax41 = fun_10002896(ecx17, v14, v11, v9, v36, v37, v16, v34, v38, v39, v40);
                                *reinterpret_cast<void***>(eax41) = reinterpret_cast<void**>(42);
                                if (v42) {
                                    *reinterpret_cast<void***>(v43 + 0x70) = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(v43 + 0x70)) & 0xfffffffd);
                                    goto addr_1000206d_22;
                                }
                            } else {
                                addr_10001f4d_23:
                            }
                        }
                    } else {
                        ecx17 = a4;
                        if (reinterpret_cast<unsigned char>(ecx17) <= reinterpret_cast<unsigned char>(0)) {
                            addr_10001ef0_25:
                            v44 = edi27->f4;
                            eax25 = reinterpret_cast<void**>(WideCharToMultiByte(v44, 0, esi13, a4, v16, a4, 0, reinterpret_cast<uint32_t>(ebp6) + 0xfffffff0));
                            if (!eax25) 
                                goto addr_10002056_7;
                            if (0) 
                                goto addr_10002056_7; else 
                                goto addr_10001f1a_27;
                        } else {
                            eax45 = esi13;
                            do {
                                if (!*reinterpret_cast<void***>(eax45)) 
                                    break;
                                eax45 = eax45 + 2;
                                --ecx17;
                            } while (ecx17);
                            if (!ecx17) 
                                goto addr_10001ef0_25;
                            if (*reinterpret_cast<void***>(eax45)) 
                                goto addr_10001ef0_25; else 
                                goto addr_10001ee8_33;
                        }
                    }
                } else {
                    eax46 = reinterpret_cast<void**>(0);
                    if (reinterpret_cast<unsigned char>(a4) > reinterpret_cast<unsigned char>(0)) {
                        do {
                            ecx17 = reinterpret_cast<void**>(0xff);
                            if (reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(esi13)) > reinterpret_cast<unsigned char>(0xff)) 
                                goto addr_10002056_7;
                            *reinterpret_cast<void***>(reinterpret_cast<unsigned char>(v16) + reinterpret_cast<unsigned char>(eax46)) = *reinterpret_cast<void***>(esi13);
                            esi13 = esi13 + 2;
                        } while (*reinterpret_cast<void***>(esi13) && (++eax46, reinterpret_cast<unsigned char>(eax46) < reinterpret_cast<unsigned char>(a4)));
                    }
                }
            }
        } else {
            eax53 = fun_10002896(ecx, v14, v11, v9, v47, v48, v16, v49, v50, v51, v52);
            *reinterpret_cast<void***>(eax53) = reinterpret_cast<void**>(22);
            fun_10002844(ecx);
            goto addr_1000206d_22;
        }
    } else {
        goto addr_10002070_39;
    }
    addr_10001ead_40:
    if (v54) {
        v55->f112 = v55->f112 & 0xfffffffd;
    }
    addr_10002070_39:
    eax56 = fun_10001cc4(v8 ^ reinterpret_cast<uint32_t>(ebp6), v36);
    return eax56;
    addr_10001ffd_19:
    if (v57) {
        v58->f112 = v58->f112 & 0xfffffffd;
    }
    goto addr_10002070_39;
    do {
        addr_10001f74_20:
        v59 = edi27->f172;
        v60 = edi27->f4;
        eax61 = reinterpret_cast<void**>(WideCharToMultiByte(ecx17, v60, 0, esi13, 1, reinterpret_cast<uint32_t>(ebp6) + 0xfffffff4, v59, 0, reinterpret_cast<uint32_t>(ebp6) + 0xfffffff0, v33, 0, v32, 0xff, v31, v30, 0, v29));
        v36 = eax61;
        if (!eax61) 
            goto addr_10002056_7;
        if (0) 
            goto addr_10002056_7;
        if (reinterpret_cast<signed char>(eax61) < reinterpret_cast<signed char>(0)) 
            goto addr_10002056_7;
        if (reinterpret_cast<unsigned char>(eax61) > reinterpret_cast<unsigned char>(5)) 
            goto addr_10002056_7;
        eax62 = v34;
        if (reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(eax61) + reinterpret_cast<unsigned char>(eax62)) > reinterpret_cast<unsigned char>(a4)) 
            goto addr_10001ead_40;
        ecx17 = reinterpret_cast<void**>(0);
        v37 = reinterpret_cast<void**>(0);
        if (reinterpret_cast<signed char>(eax61) > reinterpret_cast<signed char>(0)) {
            do {
                cl63 = *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(ebp6) + reinterpret_cast<unsigned char>(ecx17) + 0xfffffff4);
                *reinterpret_cast<signed char*>(reinterpret_cast<unsigned char>(v16) + reinterpret_cast<unsigned char>(eax62)) = cl63;
                if (!cl63) 
                    goto addr_10001ead_40;
                ecx17 = v37 + 1;
                ++eax62;
                v37 = ecx17;
                v34 = eax62;
            } while (reinterpret_cast<signed char>(ecx17) < reinterpret_cast<signed char>(v36));
        }
        esi13 = esi13 + 2;
    } while (reinterpret_cast<unsigned char>(eax62) < reinterpret_cast<unsigned char>(a4));
    goto addr_10001ffd_19;
    addr_1000206d_22:
    goto addr_10002070_39;
    addr_10001f1a_27:
    if (!*reinterpret_cast<signed char*>(reinterpret_cast<unsigned char>(v16) + reinterpret_cast<unsigned char>(eax25) + 0xffffffff)) {
        goto addr_10001f4d_23;
    }
    addr_10001ee8_33:
    a4 = reinterpret_cast<void**>((reinterpret_cast<int32_t>(reinterpret_cast<unsigned char>(eax45) - reinterpret_cast<unsigned char>(esi13)) >> 1) + 1);
    goto addr_10001ef0_25;
}

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

void fun_10002099(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13) {
    *reinterpret_cast<void***>(ecx) = reinterpret_cast<void**>(0x1000a190);
    fun_100039ef(ecx, ecx, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
    return;
}

void fun_10004570(void** a1, void** a2, void** a3) {
    void* esp4;
    void* ebp5;
    int32_t* esp6;
    int32_t ebx7;
    int32_t* esp8;
    int32_t esi9;
    int32_t* esp10;
    int32_t edi11;
    void** eax12;
    uint32_t* esp13;
    int32_t* esp14;

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

void** fun_10002817(void** ecx, int32_t a2, void** a3, void** a4, void** a5, void** a6) {
    int32_t eax7;

    eax7 = reinterpret_cast<int32_t>(DecodePointer());
    if (!eax7) {
        fun_100027f2(ecx, a2, a3, a4, a5, a6);
        fun_10002817(ecx, 0, 0, 0, 0, 0);
        goto a2;
    } else {
        goto eax7;
    }
}

void** fun_10001d91(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11) {
    void** esi12;
    void** ebp13;
    void** eax14;
    int1_t zf15;
    void** ecx16;
    void** eax17;
    int1_t zf18;
    void** ecx19;
    void** eax20;

    *reinterpret_cast<void***>(ecx + 12) = reinterpret_cast<void**>(0);
    if (a2) {
        *reinterpret_cast<void***>(ecx) = *reinterpret_cast<void***>(a2);
        *reinterpret_cast<void***>(ecx + 4) = *reinterpret_cast<void***>(a2 + 4);
    } else {
        eax14 = fun_100036bd(ecx, esi12, ebp13, __return_address(), a2, a3, a4, a5, a6);
        *reinterpret_cast<void***>(ecx + 8) = eax14;
        *reinterpret_cast<void***>(ecx) = *reinterpret_cast<void***>(eax14 + 0x6c);
        *reinterpret_cast<void***>(ecx + 4) = *reinterpret_cast<void***>(eax14 + 0x68);
        zf15 = *reinterpret_cast<void***>(ecx) == image_base_;
        if (!zf15 && (ecx16 = g1000d6f0, !(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(eax14 + 0x70)) & reinterpret_cast<unsigned char>(ecx16)))) {
            eax17 = fun_10003494(ecx16, esi12, ebp13, __return_address(), a2, a3, a4);
            *reinterpret_cast<void***>(ecx) = eax17;
        }
        zf18 = *reinterpret_cast<void***>(ecx + 4) == image_base_;
        if (!zf18 && (ecx19 = g1000d6f0, !(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(ecx + 8) + 0x70)) & reinterpret_cast<unsigned char>(ecx19)))) {
            eax20 = fun_10002d11(ecx19, esi12, ebp13, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11);
            *reinterpret_cast<void***>(ecx + 4) = eax20;
        }
        if (!(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(ecx + 8) + 0x70)) & 2)) {
            *reinterpret_cast<void***>(*reinterpret_cast<void***>(ecx + 8) + 0x70) = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(ecx + 8) + 0x70)) | 2);
            *reinterpret_cast<void***>(ecx + 12) = reinterpret_cast<void**>(1);
        }
    }
    return ecx;
}

void fun_100044ed() {
    int32_t* edi1;
    int32_t eax2;

    edi1 = reinterpret_cast<int32_t*>(0x1000c320);
    if (!1) {
        do {
            eax2 = *edi1;
            if (eax2) {
                eax2();
            }
            ++edi1;
        } while (reinterpret_cast<uint32_t>(edi1) < 0x1000c320);
    }
    return;
}

int32_t GetEnvironmentStringsW = 0xcb80;

int32_t FreeEnvironmentStringsW = 0xcb66;

void** fun_10004456(void** ecx) {
    void** edi2;
    void** edi3;
    void** v4;
    void** ebx5;
    void** v6;
    void** esi7;
    void** eax8;
    void** ebx9;
    int32_t edi10;
    void** eax11;
    void** eax12;
    void** eax13;
    void** v14;
    void** eax15;
    int32_t eax16;

    edi2 = edi3;
    v4 = ebx5;
    v6 = esi7;
    eax8 = reinterpret_cast<void**>(GetEnvironmentStringsW());
    ebx9 = eax8;
    if (ebx9) {
        if (*reinterpret_cast<void***>(ebx9)) {
            addr_10004477_3:
            eax8 = eax8 + 2;
            if (*reinterpret_cast<void***>(eax8)) 
                goto addr_10004477_3;
            eax8 = eax8 + 2;
            if (*reinterpret_cast<void***>(eax8)) 
                goto addr_10004477_3;
        }
        edi10 = WideCharToMultiByte;
        eax11 = reinterpret_cast<void**>((reinterpret_cast<int32_t>(reinterpret_cast<unsigned char>(eax8) - reinterpret_cast<unsigned char>(ebx9)) >> 1) + 1);
        eax12 = reinterpret_cast<void**>(edi10(0, 0, ebx9, eax11, 0, 0, 0, 0, edi2));
        if (!eax12 || (eax13 = fun_10003ae8(ecx, eax12, 0, 0, ebx9, eax11, 0, 0, 0, 0, edi2, v6, v4, eax11, eax12), ecx = eax12, v14 = eax13, eax13 == 0)) {
            FreeEnvironmentStringsW(ecx);
            eax15 = reinterpret_cast<void**>(0);
        } else {
            eax16 = reinterpret_cast<int32_t>(edi10(ecx, 0, 0, ebx9, eax11, eax13, eax12, 0));
            if (!eax16) {
                fun_10002416(ecx, v14, 0, 0, ebx9, eax11, eax13, eax12, 0, 0, 0, 0, ebx9, eax11, 0, 0, 0, 0, edi2);
                ecx = v14;
                v14 = reinterpret_cast<void**>(0);
            }
            FreeEnvironmentStringsW(ecx, ebx9, 0, 0, ebx9, eax11, eax13, eax12, 0);
            eax15 = v14;
        }
    } else {
        eax15 = reinterpret_cast<void**>(0);
    }
    return eax15;
}

struct s77 {
    int32_t f0;
    void** f4;
    signed char[3] pad8;
    int32_t f8;
};

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

uint32_t fun_10003e8d(void** ecx) {
    void** edi2;
    void** edi3;
    void** v4;
    void** esi5;
    void** v6;
    void** v7;
    void** v8;
    void** v9;
    void** v10;
    void** v11;
    void** v12;
    void** eax13;
    void** ecx14;
    struct s32* eax15;
    void** esi16;
    void** v17;
    void** ebx18;
    void** v19;
    int16_t v20;
    void** v21;
    void** ebx22;
    void** eax23;
    void** v24;
    int32_t* v25;
    int1_t less26;
    uint32_t eax27;
    void** edi28;
    int32_t ebx29;
    int32_t v30;
    int32_t eax31;
    struct s77* esi32;
    uint32_t eax33;
    struct s78* tmp32_34;
    void** eax35;
    uint32_t eax36;
    uint32_t eax37;
    void*** edi38;
    void** v39;
    void** v40;
    void** v41;
    void** v42;
    void** eax43;
    void** tmp32_44;
    struct s32* eax45;
    int1_t less46;

    edi2 = edi3;
    v4 = esi5;
    v6 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 + 0xffffffb4);
    GetStartupInfoW(ecx);
    eax13 = fun_10003b2d(ecx, 32, 64, v6, v4, v7, v8, v9, v10, v11, v12);
    ecx14 = reinterpret_cast<void**>(0);
    if (eax13) {
        g1000fb40 = eax13;
        g1000fb2c = reinterpret_cast<void**>(32);
        if (reinterpret_cast<unsigned char>(eax13) < reinterpret_cast<unsigned char>(eax13 + 0x800)) {
            eax15 = reinterpret_cast<struct s32*>(eax13 + 5);
            do {
                *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(eax15) + 0xfffffffb) = reinterpret_cast<void**>(0xffffffff);
                *reinterpret_cast<int16_t*>(reinterpret_cast<uint32_t>(eax15) + 0xffffffff) = 0xa00;
                eax15->f3 = reinterpret_cast<void**>(0);
                eax15->f31 = reinterpret_cast<unsigned char>(0xa00);
                *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(eax15) + 33) = 10;
                eax15->f51 = reinterpret_cast<void**>(0);
                eax15->f47 = reinterpret_cast<void**>(0);
                esi16 = g1000fb40;
                eax15 = reinterpret_cast<struct s32*>(reinterpret_cast<uint32_t>(eax15) + 64);
            } while (reinterpret_cast<unsigned char>(reinterpret_cast<uint32_t>(eax15) + 0xfffffffb) < reinterpret_cast<unsigned char>(esi16 + 0x800));
        }
        v17 = ebx18;
        v19 = edi2;
        if (!v20) 
            goto addr_10004020_6;
        if (!v21) 
            goto addr_10004020_6;
        ebx22 = *reinterpret_cast<void***>(v21);
        eax23 = v21 + 4;
        v24 = eax23;
        v25 = reinterpret_cast<int32_t*>(reinterpret_cast<unsigned char>(eax23) + reinterpret_cast<unsigned char>(ebx22));
        if (reinterpret_cast<signed char>(ebx22) >= reinterpret_cast<signed char>(0x800)) {
            ebx22 = reinterpret_cast<void**>(0x800);
        }
        less26 = reinterpret_cast<signed char>(g1000fb2c) < reinterpret_cast<signed char>(ebx22);
        if (less26) 
            goto addr_10003f3d_11;
    } else {
        eax27 = 0xffffffff;
        goto addr_100040ca_13;
    }
    addr_10003fa8_14:
    edi28 = reinterpret_cast<void**>(0);
    if (reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(ebx22) < reinterpret_cast<signed char>(0)) | reinterpret_cast<uint1_t>(ebx22 == 0)) {
        addr_10004020_6:
        ebx29 = 0;
    } else {
        do {
            if (*v25 != -1 && (*v25 != -2 && ((ecx14 = v24, ecx14 = *reinterpret_cast<void***>(ecx14), !!(reinterpret_cast<unsigned char>(ecx14) & 1)) && (reinterpret_cast<unsigned char>(ecx14) & 8 || (v30 = *v25, eax31 = reinterpret_cast<int32_t>(GetFileType(v30)), !!eax31))))) {
                esi32 = reinterpret_cast<struct s77*>(((reinterpret_cast<unsigned char>(edi28) & 31) << 6) + reinterpret_cast<int32_t>(*reinterpret_cast<int32_t**>((reinterpret_cast<signed char>(edi28) >> 5) * 4 + 0x1000fb40)));
                esi32->f0 = *v25;
                esi32->f4 = *reinterpret_cast<void***>(v24);
                eax33 = reinterpret_cast<uint32_t>(InitializeCriticalSectionAndSpinCount(esi32 + 1));
                if (!eax33) 
                    goto addr_100040cd_17;
                esi32->f8 = esi32->f8 + 1;
            }
            ++v25;
            ++edi28;
            ++v24;
        } while (reinterpret_cast<signed char>(edi28) < reinterpret_cast<signed char>(ebx22));
        goto addr_10004020_6;
    }
    do {
        tmp32_34 = reinterpret_cast<struct s78*>((ebx29 << 6) + reinterpret_cast<unsigned char>(g1000fb40));
        if (tmp32_34->f0 == 0xffffffff || tmp32_34->f0 == 0xfffffffe) {
            tmp32_34->f4 = 0x81;
            if (ebx29) {
            }
            eax35 = reinterpret_cast<void**>(GetStdHandle(ecx14));
            if (eax35 == 0xffffffff || (!eax35 || (eax36 = reinterpret_cast<uint32_t>(GetFileType(ecx14, eax35)), eax36 == 0))) {
                tmp32_34->f4 = reinterpret_cast<unsigned char>(tmp32_34->f4 | 64);
                tmp32_34->f0 = reinterpret_cast<void**>(0xfffffffe);
            } else {
                eax37 = eax36 & 0xff;
                tmp32_34->f0 = eax35;
                if (eax37 != 2) {
                    if (eax37 == 3) {
                        tmp32_34->f4 = reinterpret_cast<unsigned char>(tmp32_34->f4 | 8);
                    }
                } else {
                    tmp32_34->f4 = reinterpret_cast<unsigned char>(tmp32_34->f4 | 64);
                }
                eax33 = reinterpret_cast<uint32_t>(InitializeCriticalSectionAndSpinCount(ecx14, tmp32_34 + 1, 0xfa0, eax35));
                if (!eax33) 
                    goto addr_100040cd_17;
                tmp32_34->f8 = tmp32_34->f8 + 1;
            }
        } else {
            tmp32_34->f4 = reinterpret_cast<unsigned char>(tmp32_34->f4 | 0x80);
        }
        ++ebx29;
    } while (ebx29 < 3);
    SetHandleCount(ecx14);
    eax27 = 0;
    addr_100040c8_35:
    addr_100040ca_13:
    return eax27;
    addr_100040cd_17:
    eax27 = 0xffffffff;
    goto addr_100040c8_35;
    addr_10003f3d_11:
    edi38 = reinterpret_cast<void***>(0x1000fb44);
    do {
        eax43 = fun_10003b2d(ecx14, 32, 64, v19, v17, v6, v4, v39, v40, v41, v42);
        ecx14 = reinterpret_cast<void**>(64);
        if (!eax43) 
            break;
        tmp32_44 = g1000fb2c + 32;
        g1000fb2c = tmp32_44;
        ecx14 = eax43 + 0x800;
        *edi38 = eax43;
        if (reinterpret_cast<unsigned char>(eax43) < reinterpret_cast<unsigned char>(ecx14)) {
            eax45 = reinterpret_cast<struct s32*>(eax43 + 5);
            do {
                *reinterpret_cast<void***>(reinterpret_cast<uint32_t>(eax45) + 0xfffffffb) = reinterpret_cast<void**>(0xffffffff);
                eax45->f3 = reinterpret_cast<void**>(0);
                eax45->f31 = reinterpret_cast<unsigned char>(eax45->f31 & 0x80);
                eax45->f51 = reinterpret_cast<void**>(0);
                *reinterpret_cast<int16_t*>(reinterpret_cast<uint32_t>(eax45) + 0xffffffff) = 0xa00;
                eax45->f32 = 0xa0a;
                eax45->f47 = reinterpret_cast<void**>(0);
                eax45 = reinterpret_cast<struct s32*>(reinterpret_cast<uint32_t>(eax45) + 64);
                ecx14 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*edi38) + reinterpret_cast<unsigned char>(0x800));
            } while (reinterpret_cast<unsigned char>(reinterpret_cast<uint32_t>(eax45) + 0xfffffffb) < reinterpret_cast<unsigned char>(ecx14));
        }
        edi38 = edi38 + 4;
        less46 = reinterpret_cast<signed char>(g1000fb2c) < reinterpret_cast<signed char>(ebx22);
    } while (less46);
    goto addr_10003fa0_41;
    ebx22 = g1000fb2c;
    goto addr_10003fa8_14;
    addr_10003fa0_41:
    goto addr_10003fa8_14;
}

void** g1000e1d8;

signed char g1000e1d0;

struct s79 {
    signed char[16] pad16;
    signed char f16;
};

struct s80 {
    signed char[12] pad12;
    int32_t f12;
};

void** g1000fc48;

void** g1000fc44;

void fun_10003e35(void** ecx);

struct s81 {
    signed char[16] pad16;
    int32_t f16;
};

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

struct s83 {
    signed char[16] pad16;
    int32_t f16;
};

void** fun_10003d0a(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
    void** v8;
    int32_t ebp9;
    int1_t zf10;
    struct s79* ebp11;
    struct s80* ebp12;
    void** v13;
    int32_t esi14;
    void*** eax15;
    void*** ebx16;
    int32_t ebp17;
    void** v18;
    void*** eax19;
    void*** edi20;
    int32_t ebp21;
    int32_t ebp22;
    int32_t ebp23;
    int32_t ebp24;
    void** eax25;
    void** v26;
    int32_t eax27;
    void** eax28;
    void** v29;
    int32_t eax30;
    void** v31;
    void*** eax32;
    int32_t ebp33;
    int32_t ebp34;
    int32_t ebp35;
    int32_t ebp36;
    int32_t ebp37;
    int32_t ebp38;
    int32_t ebp39;
    int32_t ebp40;
    int32_t ebp41;
    int32_t eax42;
    int32_t ebp43;
    int32_t ebp44;
    int32_t ebp45;
    int32_t ebp46;
    int32_t ebp47;
    int32_t eax48;
    int32_t ebp49;
    int32_t ebp50;
    int32_t ebp51;
    int32_t ebp52;
    struct s81* ebp53;
    void** v54;
    struct s82* ebp55;
    struct s83* ebp56;

    v8 = reinterpret_cast<void**>(__return_address());
    fun_10004570(0x1000c490, 32, v8);
    fun_10006df1(ecx, 8, 0x1000c490, 32, v8, a2, a3, a4, a5, a6, a7);
    *reinterpret_cast<uint32_t*>(ebp9 - 4) = 0;
    zf10 = reinterpret_cast<int1_t>(g1000e1d8 == 1);
    if (!zf10) {
        g1000e1d4 = reinterpret_cast<void**>(1);
        g1000e1d0 = ebp11->f16;
        if (!ebp12->f12) {
            v13 = g1000fc48;
            esi14 = DecodePointer;
            eax15 = reinterpret_cast<void***>(esi14(8, v13));
            ebx16 = eax15;
            *reinterpret_cast<void****>(ebp17 - 48) = ebx16;
            if (ebx16) {
                v18 = g1000fc44;
                eax19 = reinterpret_cast<void***>(esi14(8, v18, v13));
                edi20 = eax19;
                *reinterpret_cast<void****>(ebp21 - 44) = edi20;
                *reinterpret_cast<void****>(ebp22 - 36) = ebx16;
                *reinterpret_cast<void****>(ebp23 - 40) = edi20;
                while (edi20 = edi20 - 4, *reinterpret_cast<void****>(ebp24 - 44) = edi20, reinterpret_cast<uint32_t>(edi20) >= reinterpret_cast<uint32_t>(ebx16)) {
                    eax25 = fun_1000350d(8, v18, v13, 0x1000c490, 32, v8, a2);
                    if (*edi20 == eax25) 
                        continue;
                    if (reinterpret_cast<uint32_t>(edi20) < reinterpret_cast<uint32_t>(ebx16)) 
                        break;
                    v26 = *edi20;
                    eax27 = reinterpret_cast<int32_t>(esi14(8, v26, v18, v13));
                    eax28 = fun_1000350d(8, v26, v18, v13, 0x1000c490, 32, v8);
                    *edi20 = eax28;
                    eax27(8, v26, v18, v13);
                    v29 = g1000fc48;
                    eax30 = reinterpret_cast<int32_t>(esi14(8, v29, v26, v18, v13));
                    v31 = g1000fc44;
                    eax32 = reinterpret_cast<void***>(esi14(8, v31, v29, v26, v18, v13));
                    if (*reinterpret_cast<int32_t*>(ebp33 - 36) != eax30 || *reinterpret_cast<void****>(ebp34 - 40) != eax32) {
                        *reinterpret_cast<int32_t*>(ebp35 - 36) = eax30;
                        *reinterpret_cast<int32_t*>(ebp36 - 48) = eax30;
                        *reinterpret_cast<void****>(ebp37 - 40) = eax32;
                        edi20 = eax32;
                        *reinterpret_cast<void****>(ebp38 - 44) = edi20;
                    }
                    ebx16 = *reinterpret_cast<void****>(ebp39 - 48);
                }
            }
            *reinterpret_cast<int32_t*>(ebp40 - 28) = 0x1000a154;
            while (*reinterpret_cast<uint32_t*>(ebp41 - 28) < 0x1000a160) {
                eax42 = **reinterpret_cast<int32_t**>(ebp43 - 28);
                if (eax42) {
                    eax42(8, v13);
                }
                *reinterpret_cast<int32_t*>(ebp44 - 28) = *reinterpret_cast<int32_t*>(ebp45 - 28) + 4;
            }
        }
        *reinterpret_cast<int32_t*>(ebp46 - 32) = 0x1000a164;
        while (*reinterpret_cast<uint32_t*>(ebp47 - 32) < 0x1000a168) {
            eax48 = **reinterpret_cast<int32_t**>(ebp49 - 32);
            if (eax48) {
                eax48(8);
            }
            *reinterpret_cast<int32_t*>(ebp50 - 32) = *reinterpret_cast<int32_t*>(ebp51 - 32) + 4;
        }
    }
    *reinterpret_cast<int32_t*>(ebp52 - 4) = -2;
    fun_10003e35(8);
    if (ebp53->f16) {
        fun_100045b5(8, 0x1000c490, 32, v8, a2, a3);
        goto 0x1000c490;
    }
    g1000e1d8 = reinterpret_cast<void**>(1);
    fun_10006d18(8, 8);
    v54 = ebp55->f8;
    fun_10003bf2(8, v54, 0x1000c490, 32, v8, a2, a3);
    if (ebp56->f16) 
        goto addr_10003e3b_25;
    addr_10003e43_26:
    goto v54;
    addr_10003e3b_25:
    fun_10006d18(8, 8);
    goto addr_10003e43_26;
}

void** fun_100074c2(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8) {
    void** v9;
    void** v10;
    void** ebp11;
    void** eax12;
    void** ecx13;
    void** v14;
    void** esi15;
    void** esi16;
    void** eax17;
    void** v18;
    int1_t zf19;
    int32_t eax20;

    v9 = reinterpret_cast<void**>(__return_address());
    v10 = ebp11;
    if (a1 && reinterpret_cast<unsigned char>(0xe0 / reinterpret_cast<unsigned char>(a1)) < reinterpret_cast<unsigned char>(a2)) {
        eax12 = fun_10002896(a1, v10, v9, a1, a2, a3, a4, a5, a6, a7, a8);
        *reinterpret_cast<void***>(eax12) = reinterpret_cast<void**>(12);
        return 0;
    }
    ecx13 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(a1) * reinterpret_cast<unsigned char>(a2));
    v14 = esi15;
    esi16 = ecx13;
    if (!esi16) {
        ++esi16;
    }
    do {
        eax17 = reinterpret_cast<void**>(0);
        if (reinterpret_cast<unsigned char>(esi16) > reinterpret_cast<unsigned char>(0xffffffe0)) 
            goto addr_1000750f_6;
        v18 = g1000e2e8;
        eax17 = reinterpret_cast<void**>(HeapAlloc(ecx13, v18, 8, esi16));
        if (eax17) 
            break;
        addr_1000750f_6:
        zf19 = g1000ead8 == 0;
        if (zf19) 
            goto addr_10007534_8;
        eax20 = fun_10004c5b(ecx13, esi16, v14, v10, v9, a1, a2);
        ecx13 = esi16;
    } while (eax20);
    goto addr_10007523_10;
    addr_10007541_11:
    return eax17;
    addr_10007534_8:
    if (a3) {
        *reinterpret_cast<void***>(a3) = reinterpret_cast<void**>(12);
        goto addr_10007541_11;
    }
    addr_10007523_10:
    if (a3) {
        *reinterpret_cast<void***>(a3) = reinterpret_cast<void**>(12);
    }
    eax17 = reinterpret_cast<void**>(0);
    goto addr_10007541_11;
}

void fun_10003632(void** ecx) {
    fun_10006d18(ecx, 13);
    return;
}

void** fun_10004a27(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void** a16) {
    void** v17;
    void** esi18;
    void** eax19;

    *reinterpret_cast<void***>(ecx) = reinterpret_cast<void**>("2J");
    if (*reinterpret_cast<void***>(ecx + 8)) {
        v17 = *reinterpret_cast<void***>(ecx + 4);
        eax19 = fun_10002416(ecx, v17, esi18, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16);
    }
    *reinterpret_cast<void***>(ecx + 4) = reinterpret_cast<void**>(0);
    *reinterpret_cast<void***>(ecx + 8) = reinterpret_cast<void**>(0);
    return eax19;
}

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

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

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

void fun_10004b9b(void** ecx);

int32_t fun_10004b65(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
    int32_t ebp7;
    void** v8;
    struct s84* ebp9;
    void** eax10;
    int32_t ebp11;
    int32_t ebp12;

    fun_10004570(0x1000c4b0, 12, __return_address());
    fun_10003c0a(ecx, 0x1000c4b0, 12, __return_address(), a2, a3, a4, a5, a6);
    *reinterpret_cast<uint32_t*>(ebp7 - 4) = 0;
    v8 = ebp9->f8;
    eax10 = fun_10004a7e(ecx, v8);
    *reinterpret_cast<void***>(ebp11 - 28) = eax10;
    *reinterpret_cast<int32_t*>(ebp12 - 4) = -2;
    fun_10004b9b(v8);
    fun_100045b5(v8, 0x1000c4b0, 12, __return_address(), a2, a3);
    goto 0x1000c4b0;
}

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

void** fun_10004a7e(void** ecx, void** a2) {
    int32_t esi3;
    void** v4;
    void** eax5;
    void** v6;
    void** eax7;
    void** esi8;
    struct s85* edi9;
    void** eax10;
    void** edi11;
    void** esi12;
    void** ebx13;
    void** ebp14;
    void** eax15;
    void** ecx16;
    int32_t edi17;
    void** eax18;
    void** eax19;
    void** eax20;
    void** eax21;
    void** eax22;
    void** eax23;
    void** eax24;

    esi3 = DecodePointer;
    v4 = g1000fc48;
    eax5 = reinterpret_cast<void**>(esi3());
    v6 = g1000fc44;
    eax7 = reinterpret_cast<void**>(esi3());
    esi8 = eax7;
    if (reinterpret_cast<unsigned char>(esi8) < reinterpret_cast<unsigned char>(eax5) || (edi9 = reinterpret_cast<struct s85*>(reinterpret_cast<unsigned char>(esi8) - reinterpret_cast<unsigned char>(eax5)), reinterpret_cast<unsigned char>(&edi9->f4) < reinterpret_cast<unsigned char>(4))) {
        addr_10004b2d_2:
        eax10 = reinterpret_cast<void**>(0);
    } else {
        eax15 = fun_10007c25(ecx, eax5, v6, v4, edi11, esi12, ebx13, eax5, ebp14);
        ecx16 = eax5;
        if (reinterpret_cast<unsigned char>(eax15) >= reinterpret_cast<unsigned char>(&edi9->f4)) {
            addr_10004b10_4:
            edi17 = EncodePointer;
            eax18 = reinterpret_cast<void**>(edi17(ecx16, a2));
            *reinterpret_cast<void***>(esi8) = eax18;
            eax19 = reinterpret_cast<void**>(edi17(ecx16, esi8 + 4, a2));
            g1000fc44 = eax19;
            eax10 = a2;
        } else {
            eax20 = reinterpret_cast<void**>(0x800);
            if (reinterpret_cast<unsigned char>(eax15) < reinterpret_cast<unsigned char>(0x800)) {
                eax20 = eax15;
            }
            eax21 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax20) + reinterpret_cast<unsigned char>(eax15));
            if (reinterpret_cast<unsigned char>(eax21) < reinterpret_cast<unsigned char>(eax15)) 
                goto addr_10004ae8_8;
            eax22 = fun_10003b79(ecx16, eax5, eax21, v6, v4, edi11, esi12, ebx13, eax5, ebp14, __return_address());
            ecx16 = eax21;
            if (eax22) 
                goto addr_10004afe_10;
            addr_10004ae8_8:
            eax23 = eax15 + 16;
            if (reinterpret_cast<unsigned char>(eax23) < reinterpret_cast<unsigned char>(eax15)) 
                goto addr_10004b2d_2;
            eax22 = fun_10003b79(ecx16, eax5, eax23, v6, v4, edi11, esi12, ebx13, eax5, ebp14, __return_address());
            ecx16 = eax23;
            if (!eax22) 
                goto addr_10004b2d_2; else 
                goto addr_10004afe_10;
        }
    }
    return eax10;
    addr_10004afe_10:
    esi8 = eax22 + (reinterpret_cast<int32_t>(edi9) >> 2) * 4;
    eax24 = reinterpret_cast<void**>(EncodePointer(ecx16, eax22));
    g1000fc48 = eax24;
    goto addr_10004b10_4;
}

void** g1000e16c;

void fun_100026ba(void** a1, void** a2) {
    g1000e16c = a1;
    return;
}

void** fun_100028df(int32_t a1, void** a2, void** a3, void** a4, void** a5, void** a6) {
    void* ebp7;
    void** v8;
    void** ebx9;
    void** v10;
    void** edi11;
    void** ecx12;
    void** esi13;
    void** v14;
    void** eax15;
    void** v16;
    void** v17;
    void** v18;
    void** v19;
    void** v20;
    void** v21;
    void** eax22;
    void** v23;
    void** v24;
    void** v25;
    void** v26;
    void** v27;
    void** v28;
    void** v29;
    void** eax30;
    uint32_t eax31;
    void* eax32;

    ebp7 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    v8 = ebx9;
    v10 = edi11;
    ecx12 = reinterpret_cast<void**>(7);
    while (ecx12) {
        --ecx12;
        esi13 = esi13 + 4;
    }
    if (a4) {
        if (!a3 || a2) {
            v14 = reinterpret_cast<void**>(0x7fffffff);
            if (reinterpret_cast<unsigned char>(a3) <= reinterpret_cast<unsigned char>(0x7fffffff)) {
                v14 = a3;
            }
            eax15 = reinterpret_cast<void**>(a1(reinterpret_cast<int32_t>(ebp7) - 32, a4, a5, a6));
            if (a2) 
                goto addr_1000296f_9;
        } else {
            eax22 = fun_10002896(ecx12, esi13, v10, v8, 0, v16, v17, v18, v19, v20, v21);
            *reinterpret_cast<void***>(eax22) = reinterpret_cast<void**>(22);
            fun_10002844(ecx12);
            eax15 = reinterpret_cast<void**>(0xffffffff);
        }
    } else {
        eax30 = fun_10002896(ecx12, v10, v8, 0, v23, v24, v25, v26, v27, v28, v29);
        *reinterpret_cast<void***>(eax30) = reinterpret_cast<void**>(22);
        fun_10002844(ecx12);
        eax15 = reinterpret_cast<void**>(0xffffffff);
        goto addr_100029a5_12;
    }
    addr_100029a4_13:
    addr_100029a5_12:
    return eax15;
    addr_1000296f_9:
    if (reinterpret_cast<signed char>(eax15) < reinterpret_cast<signed char>(0)) 
        goto addr_10002995_14;
    --v14;
    if (reinterpret_cast<signed char>(v14) < reinterpret_cast<signed char>(0)) {
        eax31 = fun_10002556(ecx12, 0, reinterpret_cast<int32_t>(ebp7) + 0xffffffe0, esi13, v10, v8, a2);
        if (eax31 == 0xffffffff) {
            addr_10002995_14:
            eax32 = reinterpret_cast<void*>(0);
            *reinterpret_cast<void***>(reinterpret_cast<unsigned char>(a2) + reinterpret_cast<unsigned char>(a3) + 0xffffffff) = reinterpret_cast<void**>(0);
            *reinterpret_cast<unsigned char*>(&eax32) = reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(v14) >= reinterpret_cast<signed char>(0));
            eax15 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(eax32) - 2);
            goto addr_100029a4_13;
        } else {
            addr_10002990_17:
            eax15 = eax15;
            goto addr_100029a4_13;
        }
    } else {
        *reinterpret_cast<void***>(a2) = reinterpret_cast<void**>(0);
        goto addr_10002990_17;
    }
}

int32_t LCMapStringW = 0xcc9e;

void** fun_10006923(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10) {
    void** v11;
    void*** esp12;
    void** v13;
    void** ebp14;
    void*** ebp15;
    void** eax16;
    void** v17;
    void** edx18;
    void** v19;
    void** ebx20;
    void** v21;
    void** esi22;
    void*** esp23;
    void** v24;
    void** edi25;
    void** v26;
    void** eax27;
    int32_t esi28;
    int32_t eax29;
    void** v30;
    void** v31;
    void** eax32;
    void** esp33;
    void** v34;
    void** eax35;
    void** v36;
    void** eax37;
    void** v38;
    int32_t eax39;
    int32_t esi40;
    void** v41;
    void** eax42;
    void** eax43;
    void** edi44;
    void** eax45;
    void** eax46;
    void** edi47;
    void** v48;
    int32_t eax49;
    void** v50;
    void** v51;
    void** eax52;
    void** eax53;

    v11 = reinterpret_cast<void**>(__return_address());
    esp12 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    v13 = ebp14;
    ebp15 = esp12;
    eax16 = g1000d050;
    v17 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax16) ^ reinterpret_cast<uint32_t>(ebp15));
    edx18 = a6;
    v19 = ebx20;
    v21 = esi22;
    esp23 = esp12 - 16 - 4 - 4 - 4;
    v24 = edi25;
    if (reinterpret_cast<signed char>(edx18) <= reinterpret_cast<signed char>(0)) {
        addr_10006960_2:
        v26 = reinterpret_cast<void**>(0);
        if (!a9) {
            a9 = *reinterpret_cast<void***>(*reinterpret_cast<void***>(a2) + 4);
        }
    } else {
        eax27 = a5;
        ecx = edx18;
        do {
            --ecx;
            if (!*reinterpret_cast<void***>(eax27)) 
                goto addr_10006953_6;
            ++eax27;
        } while (ecx);
        goto addr_10006950_8;
    }
    esi28 = MultiByteToWideChar;
    eax29 = 0;
    *reinterpret_cast<unsigned char*>(&eax29) = reinterpret_cast<uint1_t>(!!a10);
    v30 = reinterpret_cast<void**>(eax29 * 8 + 1);
    v31 = a9;
    eax32 = reinterpret_cast<void**>(esi28(v31, v30, a5, a6, 0, 0));
    esp33 = reinterpret_cast<void**>(esp23 - 4 - 4 - 4 - 4 - 4 - 4 - 4 + 4);
    if (!eax32) 
        goto addr_1000699f_10;
    if (reinterpret_cast<signed char>(eax32) <= reinterpret_cast<signed char>(0) || (esp33 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp33 - 4) + 4), 0xe0 / reinterpret_cast<unsigned char>(eax32) < 2)) {
        v34 = reinterpret_cast<void**>(0);
    } else {
        eax35 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax32) + reinterpret_cast<unsigned char>(eax32) + 8);
        if (reinterpret_cast<unsigned char>(eax35) > reinterpret_cast<unsigned char>(0x400)) {
            eax37 = fun_10004bb8(ecx, eax35, v31, v30, a5, a6, 0, 0, v24, v21, v19, eax32, v36, 0, v17, v13, v11, a2, a3, a4);
            ecx = eax35;
            esp33 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp33 - 4) - 4 + 4 + 4);
            if (!eax37) {
                addr_100069e6_15:
                v34 = eax37;
            } else {
                *reinterpret_cast<void***>(eax37) = reinterpret_cast<void**>(0xdddd);
                goto addr_100069e3_17;
            }
        } else {
            fun_100082b0(ecx, v31, v30, a5, a6, 0, 0, v24, v21, v19, eax32, v38, 0, v17, v13, v11, a2, a3, a4);
            esp33 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp33 - 4) + 4);
            eax37 = esp33;
            if (!eax37) 
                goto addr_100069e6_15;
            v31 = reinterpret_cast<void**>(0xcccc);
            goto addr_100069e3_17;
        }
    }
    if (!v34) {
        addr_1000699f_10:
    } else {
        eax39 = reinterpret_cast<int32_t>(esi28(ecx, a9, 1, a5, a6, v34, eax32, v31, v30, a5, a6, 0, 0));
        if (!eax39) 
            goto addr_10006aec_22;
        esi40 = LCMapStringW;
        v41 = a3;
        eax42 = reinterpret_cast<void**>(esi40(ecx, v41, a4, v34, eax32, 0, 0, a9, 1, a5, a6, v34, eax32, v31, v30, a5, a6, 0, 0));
        v26 = eax42;
        if (!eax42) 
            goto addr_10006aec_22;
        ecx = reinterpret_cast<void**>(0x400);
        if (!(reinterpret_cast<unsigned char>(a4) & reinterpret_cast<unsigned char>(0x400))) 
            goto addr_10006a5e_25; else 
            goto addr_10006a35_26;
    }
    addr_10006af8_27:
    eax43 = fun_10001cc4(reinterpret_cast<unsigned char>(v17) ^ reinterpret_cast<uint32_t>(ebp15), eax32);
    return eax43;
    addr_10006a5e_25:
    if (reinterpret_cast<signed char>(v26) <= reinterpret_cast<signed char>(0) || 0xe0 / reinterpret_cast<unsigned char>(v26) < 2) {
        edi44 = reinterpret_cast<void**>(0);
    } else {
        eax45 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v26) + reinterpret_cast<unsigned char>(v26) + 8);
        if (reinterpret_cast<unsigned char>(eax45) > reinterpret_cast<unsigned char>(0x400)) {
            eax46 = fun_10004bb8(0x400, eax45, v41, a4, v34, eax32, 0, 0, a9, 1, a5, a6, v34, eax32, v31, v30, a5, a6, 0, 0);
            ecx = eax45;
            if (eax46) {
                *reinterpret_cast<void***>(eax46) = reinterpret_cast<void**>(0xdddd);
                eax46 = eax46 + 8;
            }
            edi44 = eax46;
        } else {
            fun_100082b0(0x400, v41, a4, v34, eax32, 0, 0, a9, 1, a5, a6, v34, eax32, v31, v30, a5, a6, 0, 0);
            edi47 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(reinterpret_cast<uint32_t>(esp33 - 4) - 4 - 4 - 4 - 4 - 4 - 4 + 4) - 4 - 4 - 4 - 4 - 4 - 4 - 4 + 4) - 4 + 4) - 4 + 4);
            if (!edi47) {
                addr_10006aec_22:
                fun_10006903(ecx, v34, a9, 1, a5, a6, v34, eax32, v31, v30, a5, a6, 0, 0, v24, v21, v19, eax32, v34, v26, v17, v13, v11, a2, a3, a4);
                goto addr_10006af8_27;
            } else {
                v41 = reinterpret_cast<void**>(0xcccc);
                edi44 = edi47 + 8;
            }
        }
    }
    if (edi44) {
        v48 = v26;
        eax49 = reinterpret_cast<int32_t>(esi40(ecx, a3, a4, v34, eax32, edi44, v48, v41, a4, v34, eax32, 0, 0, a9, 1, a5, a6, v34, eax32, v31, v30, a5, a6, 0, 0));
        if (eax49) {
            if (a8) {
                v50 = a8;
                v51 = a7;
            } else {
                v50 = reinterpret_cast<void**>(0);
                v51 = reinterpret_cast<void**>(0);
            }
            eax52 = reinterpret_cast<void**>(WideCharToMultiByte(ecx, a9, 0, edi44, v26, v51, v50, 0, 0, a3, a4, v34, eax32, edi44, v48, v41, a4, v34, eax32, 0, 0, a9, 1, a5, a6, v34, eax32, v31, v30, a5, a6, 0, 0));
            v26 = eax52;
        }
        fun_10006903(ecx, edi44, a3, a4, v34, eax32, edi44, v48, v41, a4, v34, eax32, 0, 0, a9, 1, a5, a6, v34, eax32, v31, v30, a5, a6, 0, 0);
        ecx = edi44;
        goto addr_10006aec_22;
    }
    addr_10006a35_26:
    if (a8 && reinterpret_cast<signed char>(v26) <= reinterpret_cast<signed char>(a8)) {
        esi40(a3, a4, v34, eax32, a7, a8, v41, a4, v34, eax32, 0, 0, a9, 1, a5, a6, v34, eax32, v31, v30, a5, a6, 0, 0);
        goto addr_10006aec_22;
    }
    addr_100069e3_17:
    eax37 = eax37 + 8;
    goto addr_100069e6_15;
    addr_10006953_6:
    eax53 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edx18) - reinterpret_cast<unsigned char>(ecx) - 1);
    if (reinterpret_cast<signed char>(eax53) < reinterpret_cast<signed char>(edx18)) {
        ++eax53;
    }
    a6 = eax53;
    goto addr_10006960_2;
    addr_10006950_8:
    ecx = reinterpret_cast<void**>(0xffffffff);
    goto addr_10006953_6;
}

struct s86 {
    signed char[112] pad112;
    uint32_t f112;
};

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

int32_t GetACP = 0xca30;

int32_t GetOEMCP = 0xca3a;

struct s88 {
    signed char[112] pad112;
    uint32_t f112;
};

void** fun_10002db5(void** a1, void** a2, void** a3) {
    void** ecx4;
    void** ebx5;
    void** v6;
    void** v7;
    void** v8;
    void** v9;
    void** ebp10;
    int32_t esi11;
    int32_t esi12;
    int32_t esi13;
    signed char v14;
    struct s86* v15;
    void** eax16;
    void** esi17;
    struct s87* v18;
    signed char v19;
    struct s88* v20;

    ecx4 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 + 0xfffffff0);
    fun_10001d91(ecx4, 0, ebx5, v6, v7, v8, v9, ebp10, __return_address(), a1, a2);
    g1000e170 = reinterpret_cast<void**>(0);
    if (esi11 != -2) {
        if (esi12 != -3) {
            if (esi13 != -4) {
                if (v14) {
                    v15->f112 = v15->f112 & 0xfffffffd;
                }
                eax16 = esi17;
            } else {
                eax16 = v18->f4;
                g1000e170 = reinterpret_cast<void**>(1);
                goto addr_10002de4_8;
            }
        } else {
            g1000e170 = reinterpret_cast<void**>(1);
            eax16 = reinterpret_cast<void**>(GetACP(ecx4));
            goto addr_10002de4_8;
        }
    } else {
        g1000e170 = reinterpret_cast<void**>(1);
        eax16 = reinterpret_cast<void**>(GetOEMCP(ecx4));
        goto addr_10002de4_8;
    }
    addr_10002e2e_11:
    return eax16;
    addr_10002de4_8:
    if (v19) {
        v20->f112 = v20->f112 & 0xfffffffd;
        goto addr_10002e2e_11;
    }
}

void fun_1000317d(void** ecx, void** a2, void** a3, void** a4, void** a5) {
    fun_10006d18(ecx, 13);
    return;
}

void fun_10003501(void** ecx) {
    fun_10006d18(ecx, 12);
    return;
}

void fun_100037f1(void** ecx) {
    fun_10006d18(ecx, 13);
    return;
}

void fun_100037fd(void** ecx) {
    fun_10006d18(ecx, 12);
    return;
}

void** g1000e2ec;

void fun_10004c4c(void** a1) {
    g1000e2ec = a1;
    return;
}

void** g1000e4a8;

void fun_1000784f(void** a1, void** a2, void** a3) {
    g1000e4a8 = a1;
    return;
}

void** g1000e4a4;

void fun_10007840(void** a1, void** a2, void** a3, void** a4) {
    g1000e4a4 = a1;
    return;
}

void fun_1000763b(void** a1, void** a2, void** a3, void** a4, void** a5) {
    g1000e490 = a1;
    g1000e494 = a1;
    g1000e498 = a1;
    g1000e49c = a1;
    return;
}

int32_t g1000e48c;

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

void fun_1000762a(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6) {
    int32_t eax7;

    eax7 = reinterpret_cast<int32_t>(EncodePointer());
    g1000e48c = eax7;
    goto fun_100075f1;
}

int32_t fun_10003c4f(void** ecx, int32_t* a2, int32_t* a3) {
    int32_t* esi4;
    int32_t eax5;
    int32_t ecx6;

    esi4 = a2;
    eax5 = 0;
    while (reinterpret_cast<uint32_t>(esi4) < reinterpret_cast<uint32_t>(a3) && !eax5) {
        ecx6 = *esi4;
        if (ecx6) {
            eax5 = reinterpret_cast<int32_t>(ecx6());
        }
        ++esi4;
    }
    return eax5;
}

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

struct s90 {
    signed char[8] pad8;
    struct s89* f8;
};

void fun_10003a56(void** ecx);

void** g1000e1a0;

void fun_100039ef(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15) {
    void** v16;
    int32_t ebp17;
    struct s89* esi18;
    struct s90* ebp19;
    void** ecx20;
    int32_t ebp21;
    void** eax22;
    void** edx23;
    int32_t ebp24;
    void** v25;
    void** ecx26;

    v16 = reinterpret_cast<void**>(__return_address());
    fun_10004570(0x1000c470, 12, v16);
    fun_10006df1(ecx, 14, 0x1000c470, 12, v16, a2, a3, a4, a5, a6, a7);
    *reinterpret_cast<uint32_t*>(ebp17 - 4) = 0;
    esi18 = ebp19->f8;
    ecx20 = esi18->f4;
    if (!ecx20) {
        addr_10003a40_2:
        *reinterpret_cast<int32_t*>(ebp21 - 4) = -2;
        fun_10003a56(ecx20);
        fun_100045b5(ecx20, 0x1000c470, 12, v16, a2, a3);
        goto 0x1000c470;
    } else {
        eax22 = g1000e1a0;
        edx23 = reinterpret_cast<void**>(0x1000e19c);
        while (*reinterpret_cast<void***>(ebp24 - 28) = eax22, !!eax22) {
            if (*reinterpret_cast<void***>(eax22) == ecx20) 
                goto addr_10003a26_6;
            edx23 = eax22;
        }
    }
    addr_10003a33_8:
    v25 = esi18->f4;
    fun_10002416(ecx20, v25, 0x1000c470, 12, v16, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
    ecx20 = v25;
    esi18->f4 = reinterpret_cast<void**>(0);
    goto addr_10003a40_2;
    addr_10003a26_6:
    ecx26 = *reinterpret_cast<void***>(eax22 + 4);
    *reinterpret_cast<void***>(edx23 + 4) = ecx26;
    fun_10002416(ecx26, eax22, 0x1000c470, 12, v16, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
    ecx20 = eax22;
    goto addr_10003a33_8;
}

void fun_10003a56(void** ecx) {
    fun_10006d18(ecx, 14);
    return;
}

int32_t HeapReAlloc = 0xcce2;

void** fun_10007544(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void** a16, void** a17) {
    void** v18;
    void** v19;
    void** ebp20;
    void** eax21;
    void** v22;
    void** esi23;
    void** esi24;
    void** v25;
    void** edi26;
    void** v27;
    void** eax28;
    int1_t zf29;
    int32_t eax30;
    void** eax31;
    void** eax32;
    void** eax33;
    void** eax34;
    void** eax35;
    void** eax36;
    void** eax37;

    v18 = reinterpret_cast<void**>(__return_address());
    v19 = ebp20;
    if (!a2) {
        eax21 = fun_10004bb8(ecx, a3, v19, v18, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17);
        return eax21;
    }
    v22 = esi23;
    esi24 = a3;
    if (esi24) {
        v25 = edi26;
        do {
            if (reinterpret_cast<unsigned char>(esi24) > reinterpret_cast<unsigned char>(0xffffffe0)) 
                break;
            if (!esi24) {
                ++esi24;
            }
            v27 = g1000e2e8;
            eax28 = reinterpret_cast<void**>(HeapReAlloc(ecx, v27, 0, a2, esi24));
            if (eax28) 
                goto addr_100075ed_9;
            zf29 = g1000ead8 == eax28;
            if (zf29) 
                goto addr_100075d7_11;
            eax30 = fun_10004c5b(ecx, esi24, v27, 0, a2, esi24, v25);
            ecx = esi24;
        } while (eax30);
        goto addr_100075bf_13;
    } else {
        fun_10002416(ecx, a2, v22, v19, v18, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15);
        goto addr_100075bc_15;
    }
    fun_10004c5b(ecx, esi24, v25, v22, v19, v18, a2);
    eax31 = fun_10002896(esi24, v25, v22, v19, v18, a2, a3, a4, a5, a6, a7);
    *reinterpret_cast<void***>(eax31) = reinterpret_cast<void**>(12);
    addr_100075b9_17:
    addr_100075bb_18:
    addr_100075bc_15:
    goto v18;
    addr_100075ed_9:
    goto addr_100075bb_18;
    addr_100075d7_11:
    eax32 = fun_10002896(ecx, v27, 0, a2, esi24, v25, v22, v19, v18, a2, a3);
    eax33 = reinterpret_cast<void**>(GetLastError(ecx, v27, 0, a2, esi24));
    eax34 = fun_10002854(ecx, eax33, v27, 0, a2, esi24);
    *reinterpret_cast<void***>(eax32) = eax34;
    goto addr_100075ed_9;
    addr_100075bf_13:
    eax35 = fun_10002896(ecx, v27, 0, a2, esi24, v25, v22, v19, v18, a2, a3);
    eax36 = reinterpret_cast<void**>(GetLastError(ecx, v27, 0, a2, esi24));
    eax37 = fun_10002854(ecx, eax36, v27, 0, a2, esi24);
    *reinterpret_cast<void***>(eax35) = eax37;
    goto addr_100075b9_17;
}

struct s91 {
    int32_t f0;
    signed char[20] pad24;
    int16_t f24;
};

int32_t fun_10007860(struct s47* a1) {
    struct s91* eax2;
    int32_t edx3;

    if (a1->f0 != 0x5a4d || (eax2 = reinterpret_cast<struct s91*>(a1->f60 + reinterpret_cast<int32_t>(a1)), eax2->f0 != 0x4550)) {
        return 0;
    } else {
        edx3 = 0;
        *reinterpret_cast<unsigned char*>(&edx3) = reinterpret_cast<uint1_t>(eax2->f24 == 0x10b);
        return edx3;
    }
}

void fun_10005891(void** ecx) {
    int32_t v2;
    int32_t esi3;
    uint32_t edi4;
    int32_t eax5;

    v2 = esi3;
    edi4 = 0;
    do {
        eax5 = reinterpret_cast<int32_t>(EncodePointer());
        *reinterpret_cast<int32_t*>(edi4 + 0x1000dc10) = eax5;
        edi4 = edi4 + 4;
    } while (edi4 < 40);
    goto v2;
}

void fun_10003c13(void** ecx) {
    fun_10006d18(ecx, 8);
    return;
}

struct s92 {
    signed char[200] pad200;
    uint16_t* f200;
};

struct s93 {
    signed char[112] pad112;
    uint32_t f112;
};

uint32_t fun_10007bba(void** a1, void** a2, void** a3, unsigned char a4) {
    void** v5;
    void** v6;
    void** v7;
    void** v8;
    void** ebp9;
    uint32_t eax10;
    void* v11;
    uint32_t eax12;
    struct s92* v13;
    signed char v14;
    struct s93* v15;

    fun_10001d91(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 + 0xfffffff0, a1, v5, v6, v7, v8, ebp9, __return_address(), a1, a2, a3);
    eax10 = *reinterpret_cast<unsigned char*>(&a2);
    if (*reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(v11) + eax10 + 29) & a4) {
        addr_10007bfb_2:
        eax12 = 1;
    } else {
        if (!a3) {
            eax12 = 0;
        } else {
            eax12 = static_cast<uint32_t>(v13->f200[eax10]) & reinterpret_cast<unsigned char>(a3);
        }
        if (eax12) 
            goto addr_10007bfb_2;
    }
    if (v14) {
        v15->f112 = v15->f112 & 0xfffffffd;
    }
    return eax12;
}

void fun_10007479(void** ecx, void** a2, uint32_t a3, void** a4, void** a5, void** a6, struct s56* a7) {
    fun_100083f5(ecx, 1, __return_address(), a2, a3, a4, a5, a6, a7);
    goto ecx;
}

void fun_100090d2();

void fun_10007492(void** ecx) {
    int32_t edi2;

    fun_100090d2();
    goto edi2;
}

void** fun_100079ac(void** a1) {
    uint32_t eax2;

    eax2 = 0;
    do {
        if (a1 == *reinterpret_cast<void***>(eax2 * 8 + 0x1000bef0)) 
            break;
        ++eax2;
    } while (eax2 < 22);
    goto addr_100079c5_4;
    return *reinterpret_cast<void***>(eax2 * 8 + 0x1000bef4);
    addr_100079c5_4:
    return 0;
}

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

void fun_10007de6(int32_t a1);

void fun_10004e3c(void** ecx) {
    int32_t v2;
    struct s94* ebp3;

    v2 = ebp3->f8;
    fun_10007de6(v2);
    return;
}

void fun_10007f80(void** ecx) {
    int32_t v2;
    void* esp3;
    void* ecx4;
    int32_t* ecx5;
    int32_t eax6;
    int32_t eax7;
    int32_t eax8;
    uint32_t eax9;
    int32_t eax10;
    void* eax11;
    int32_t* eax12;

    v2 = reinterpret_cast<int32_t>(__return_address());
    esp3 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    ecx4 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp3) + 4);
    ecx5 = reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(ecx4) - eax6 & ~(eax7 - (eax8 + reinterpret_cast<uint1_t>(eax9 < eax10 + reinterpret_cast<uint1_t>(reinterpret_cast<uint32_t>(ecx4) < reinterpret_cast<uint32_t>(eax11))))));
    eax12 = reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esp3) & 0xfffff000);
    while (reinterpret_cast<uint32_t>(ecx5) < reinterpret_cast<uint32_t>(eax12)) {
        eax12 = eax12 - 0x400;
    }
    *ecx5 = v2;
    goto *ecx5;
}

void fun_1000560f(void** ecx) {
    int32_t ebx2;

    fun_10007de6(ebx2);
    return;
}

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

    eax6 = fun_100080f8(ecx, 1, __return_address(), a2, a3, a4, a5);
    return eax6;
}

void fun_10005800(void** a1) {
    int32_t ebp2;

    if (reinterpret_cast<unsigned char>(a1) < reinterpret_cast<unsigned char>(0x1000d990) || reinterpret_cast<unsigned char>(a1) > reinterpret_cast<unsigned char>(0x1000dbf0)) {
        LeaveCriticalSection();
        goto ebp2;
    } else {
        *reinterpret_cast<void***>(a1 + 12) = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a1 + 12)) & 0xffff7fff);
        fun_10006d18(0x1000d990, (reinterpret_cast<int32_t>(reinterpret_cast<unsigned char>(a1) - reinterpret_cast<unsigned char>(0x1000d990)) >> 5) + 16);
        return;
    }
}

struct s95 {
    signed char[16] pad16;
    void** f16;
};

void fun_1000583c(struct s95* a1, void** a2) {
    int32_t ebp3;
    void** ecx4;

    if (reinterpret_cast<int32_t>(a1) >= 20) {
        LeaveCriticalSection();
        goto ebp3;
    } else {
        *reinterpret_cast<void***>(a2 + 12) = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a2 + 12)) & 0xffff7fff);
        ecx4 = reinterpret_cast<void**>(&a1->f16);
        fun_10006d18(ecx4, ecx4);
        return;
    }
}

struct s96 {
    signed char[4] pad4;
    void** f4;
    signed char[15] pad20;
    void** f20;
};

struct s97 {
    signed char[112] pad112;
    uint32_t f112;
};

struct s98 {
    signed char[112] pad112;
    uint32_t f112;
};

struct s99 {
    signed char[112] pad112;
    uint32_t f112;
};

void** fun_1000595b(void** ecx, void** a2, void** a3, void** a4, uint16_t a5, void** a6) {
    void*** ebp7;
    void** edi8;
    void** esi9;
    void** ebx10;
    void** v11;
    void** v12;
    void** v13;
    void** v14;
    void** ebp15;
    struct s96* v16;
    void** v17;
    void** ecx18;
    void** v19;
    void** eax20;
    int32_t eax21;
    void** v22;
    void** v23;
    void** eax24;
    void** v25;
    void** v26;
    void** eax27;
    void** eax28;
    signed char v29;
    struct s97* v30;
    uint16_t ax31;
    void** v32;
    void** v33;
    void** v34;
    void** v35;
    signed char v36;
    struct s98* v37;
    void** v38;
    void** v39;
    void** eax40;
    void** esi41;
    signed char v42;
    struct s99* v43;
    void** v44;
    void** v45;
    void** v46;
    void** v47;
    void** eax48;

    ebp7 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    if (a3 || reinterpret_cast<unsigned char>(a4) <= reinterpret_cast<unsigned char>(0)) {
        if (a2) {
            *reinterpret_cast<void***>(a2) = reinterpret_cast<void**>(0xffffffff);
        }
        if (reinterpret_cast<unsigned char>(a4) > reinterpret_cast<unsigned char>(0x7fffffff)) 
            goto addr_10005995_5;
    } else {
        if (a2) {
            *reinterpret_cast<void***>(a2) = reinterpret_cast<void**>(0);
            goto addr_1000597f_8;
        }
    }
    fun_10001d91(ebp7 + 0xfffffff0, a6, edi8, esi9, ebx10, v11, v12, v13, v14, ebp15, __return_address());
    if (v16->f20) {
        v17 = reinterpret_cast<void**>(ebp7 + 12);
        ecx18 = reinterpret_cast<void**>(ebp7 + 20);
        v19 = v16->f4;
        eax20 = reinterpret_cast<void**>(WideCharToMultiByte(v19, 0, ecx18, 1, a3, a4, 0, v17));
        if (!eax20) {
            eax21 = reinterpret_cast<int32_t>(GetLastError(v19, 0, ecx18, 1, a3, a4, 0, v17));
            if (eax21 != 0x7a) {
                addr_100059e0_12:
                eax24 = fun_10002896(ecx18, edi8, esi9, ebx10, 1, v22, v23, 0, ebp15, __return_address(), a2);
                *reinterpret_cast<void***>(eax24) = reinterpret_cast<void**>(42);
                eax27 = fun_10002896(ecx18, edi8, esi9, ebx10, 1, v25, v26, 0, ebp15, __return_address(), a2);
                eax28 = *reinterpret_cast<void***>(eax27);
                if (v29) {
                    v30->f112 = v30->f112 & 0xfffffffd;
                }
            } else {
                if (a3 && reinterpret_cast<unsigned char>(a4) > reinterpret_cast<unsigned char>(0)) {
                    fun_10005bc0(ecx18, a3, 0, a4, v19, 0, ecx18, 1, a3, a4, 0, v17);
                    goto addr_10005a0b_16;
                }
            }
        } else {
            if (0) 
                goto addr_100059e0_12;
            if (a2) {
                *reinterpret_cast<void***>(a2) = eax20;
                goto addr_10005a3a_20;
            }
        }
    } else {
        ax31 = a5;
        ecx18 = reinterpret_cast<void**>(0xff);
        if (ax31 > 0xff) {
            if (a3 && reinterpret_cast<unsigned char>(a4) > reinterpret_cast<unsigned char>(0)) {
                fun_10005bc0(0xff, a3, 0, a4, edi8, esi9, ebx10, v32, v33, v34, v35, ebp15);
                goto addr_100059e0_12;
            }
        }
        if (!a3) 
            goto addr_10005a2d_25; else 
            goto addr_10005a07_26;
    }
    addr_100059fe_27:
    return eax28;
    addr_10005a3a_20:
    if (v36) {
        v37->f112 = v37->f112 & 0xfffffffd;
    }
    addr_1000597f_8:
    eax28 = reinterpret_cast<void**>(0);
    goto addr_100059fe_27;
    addr_10005a2d_25:
    if (a2) {
        *reinterpret_cast<void***>(a2) = reinterpret_cast<void**>(1);
        goto addr_10005a3a_20;
    }
    addr_10005a07_26:
    if (reinterpret_cast<unsigned char>(a4) > reinterpret_cast<unsigned char>(0)) {
        *reinterpret_cast<void***>(a3) = *reinterpret_cast<void***>(&ax31);
        goto addr_10005a2d_25;
    } else {
        addr_10005a0b_16:
        eax40 = fun_10002896(ecx18, edi8, esi9, ebx10, 1, v38, v39, 0, ebp15, __return_address(), a2);
        esi41 = reinterpret_cast<void**>(34);
        *reinterpret_cast<void***>(eax40) = reinterpret_cast<void**>(34);
        fun_10002844(ecx18);
        if (v42) {
            v43->f112 = v43->f112 & 0xfffffffd;
        }
    }
    addr_100059a4_32:
    eax28 = esi41;
    goto addr_100059fe_27;
    addr_10005995_5:
    eax48 = fun_10002896(ecx, edi8, esi9, ebx10, v44, v45, v46, v47, ebp15, __return_address(), a2);
    esi41 = reinterpret_cast<void**>(22);
    *reinterpret_cast<void***>(eax48) = reinterpret_cast<void**>(22);
    fun_10002844(ecx);
    goto addr_100059a4_32;
}

struct s100 {
    signed char[200] pad200;
    uint16_t* f200;
};

struct s101 {
    signed char[112] pad112;
    uint32_t f112;
};

uint32_t fun_10005acd(void** ecx, void** a2, void** a3, void** a4) {
    void** v5;
    void** v6;
    void** v7;
    void** v8;
    void** ebp9;
    uint32_t eax10;
    struct s100* v11;
    signed char v12;
    struct s101* v13;

    fun_10001d91(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 + 0xfffffff0, a3, v5, v6, v7, v8, ebp9, __return_address(), a2, a3, a4);
    eax10 = static_cast<uint32_t>(v11->f200[*reinterpret_cast<unsigned char*>(&a2)]) & 0x8000;
    if (v12) {
        v13->f112 = v13->f112 & 0xfffffffd;
    }
    return eax10;
}

void fun_10006de8(void** ecx) {
    fun_10006d18(ecx, 10);
    return;
}

int32_t fun_10007690();

unsigned char g1000dde0 = 2;

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

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

void fun_10008417(void** a1, void** a2, void** a3, void** a4, void** a5) {
    int32_t eax6;
    int1_t zf7;
    void** esi8;
    void** ecx9;
    void** edi10;
    int1_t zf11;
    int1_t zf12;
    uint32_t ecx13;
    uint32_t edx14;
    uint32_t eax15;
    struct s102* esi16;
    struct s103* edi17;
    uint32_t ecx18;
    uint32_t edx19;
    void* eax20;
    uint32_t edx21;
    void** v22;
    uint32_t eax23;
    uint32_t ecx24;
    uint32_t eax25;
    uint32_t ecx26;
    uint32_t edx27;
    uint32_t edx28;
    uint32_t ecx29;
    uint32_t eax30;
    uint32_t ecx31;
    uint32_t ecx32;

    eax6 = fun_10007690();
    if (eax6) {
        fun_1000769d(22, __return_address(), a1, a2, a3, a4, a5);
    }
    zf7 = (g1000dde0 & 2) == 0;
    if (!zf7) {
        fun_100026c9(22, 3, 0x40000015, 1, __return_address(), a1);
    }
    fun_10003e4a(22, 3, __return_address(), a1, a2);
    esi8 = a1;
    ecx9 = a2;
    edi10 = reinterpret_cast<void**>(__return_address());
    if (reinterpret_cast<unsigned char>(edi10) <= reinterpret_cast<unsigned char>(esi8) || reinterpret_cast<unsigned char>(edi10) >= reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(ecx9) + reinterpret_cast<unsigned char>(esi8))) {
        if (reinterpret_cast<unsigned char>(ecx9) < reinterpret_cast<unsigned char>(0x80) || ((zf11 = g1000eb00 == 0, zf11) || (zf12 = (reinterpret_cast<unsigned char>(edi10) & 15) == (reinterpret_cast<unsigned char>(esi8) & 15), esi8 = esi8, edi10 = edi10, !zf12))) {
            if (reinterpret_cast<unsigned char>(edi10) & 3) {
                if (reinterpret_cast<unsigned char>(ecx9) < reinterpret_cast<unsigned char>(4)) {
                    goto *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(ecx9 - 4) * 4 + 0x100085d0);
                } else {
                    goto *reinterpret_cast<int32_t*>((reinterpret_cast<unsigned char>(edi10) & 3) * 4 + 0x100084d4);
                }
            }
            ecx13 = reinterpret_cast<unsigned char>(ecx9) >> 2;
            edx14 = reinterpret_cast<unsigned char>(ecx9) & 3;
            if (ecx13 >= 8) 
                goto addr_100084a7_13;
        } else {
            eax15 = reinterpret_cast<unsigned char>(esi8) & 15;
            if (eax15) 
                goto addr_10008ddb_16; else 
                goto addr_10008d1a_17;
        }
    } else {
        esi16 = reinterpret_cast<struct s102*>(reinterpret_cast<unsigned char>(ecx9) + reinterpret_cast<unsigned char>(esi8) + 0xfffffffc);
        edi17 = reinterpret_cast<struct s103*>(reinterpret_cast<unsigned char>(ecx9) + reinterpret_cast<unsigned char>(edi10) + 0xfffffffc);
        if (reinterpret_cast<uint32_t>(edi17) & 3) {
            if (reinterpret_cast<unsigned char>(ecx9) >= reinterpret_cast<unsigned char>(4)) {
                goto *reinterpret_cast<int32_t*>((reinterpret_cast<uint32_t>(edi17) & 3) * 4 + 0x10008660);
            }
            goto *reinterpret_cast<int32_t*>(reinterpret_cast<unsigned char>(ecx9) * 4 + 0x1000875c);
        } else {
            ecx18 = reinterpret_cast<unsigned char>(ecx9) >> 2;
            edx19 = reinterpret_cast<unsigned char>(ecx9) & 3;
            if (ecx18 < 8) {
                goto *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(-ecx18) * 4 + 0x1000870c);
                goto *reinterpret_cast<int32_t*>(edx19 * 4 + 0x1000875c);
            } else {
                while (ecx18) {
                    --ecx18;
                    edi17->f0 = esi16->f0;
                    edi17 = reinterpret_cast<struct s103*>(reinterpret_cast<uint32_t>(edi17) - 4);
                    esi16 = reinterpret_cast<struct s102*>(reinterpret_cast<uint32_t>(esi16) - 4);
                }
                goto *reinterpret_cast<int32_t*>(edx19 * 4 + 0x1000875c);
            }
        }
    }
    switch (ecx13) {
        addr_100085b7_30:
    case 0:
        switch (edx14) {
        case 0:
            goto 3;
        case 1:
            *reinterpret_cast<void***>(edi10) = *reinterpret_cast<void***>(esi8);
            goto 3;
        case 2:
            *reinterpret_cast<void***>(edi10) = *reinterpret_cast<void***>(esi8);
            *reinterpret_cast<void***>(edi10 + 1) = *reinterpret_cast<void***>(esi8 + 1);
            goto 3;
        case 3:
            *reinterpret_cast<void***>(edi10) = *reinterpret_cast<void***>(esi8);
            *reinterpret_cast<void***>(edi10 + 1) = *reinterpret_cast<void***>(esi8 + 1);
            *reinterpret_cast<void***>(edi10 + 2) = *reinterpret_cast<void***>(esi8 + 2);
            goto 3;
        }
        addr_100085a4_35:
    case 1:
        *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(edi10 + ecx13 * 4) - 4) = *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esi8 + ecx13 * 4) - 4);
        eax20 = reinterpret_cast<void*>(ecx13 * 4);
        esi8 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(esi8) + reinterpret_cast<uint32_t>(eax20));
        edi10 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(edi10) + reinterpret_cast<uint32_t>(eax20));
        goto addr_100085b7_30;
        addr_1000859c_36:
    case 2:
        *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(edi10 + ecx13 * 4) - 8) = *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esi8 + ecx13 * 4) - 8);
        goto addr_100085a4_35;
        addr_10008594_37:
    case 3:
        *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(edi10 + ecx13 * 4) - 12) = *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esi8 + ecx13 * 4) - 12);
        goto addr_1000859c_36;
        addr_1000858c_38:
    case 4:
        *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(edi10 + ecx13 * 4) - 16) = *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esi8 + ecx13 * 4) - 16);
        goto addr_10008594_37;
        addr_10008584_39:
    case 5:
        *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(edi10 + ecx13 * 4) - 20) = *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esi8 + ecx13 * 4) - 20);
        goto addr_1000858c_38;
        addr_1000857c_40:
    case 6:
        *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(edi10 + ecx13 * 4) - 24) = *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esi8 + ecx13 * 4) - 24);
        goto addr_10008584_39;
    case 7:
        *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(edi10 + ecx13 * 4) - 28) = *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esi8 + ecx13 * 4) - 28);
        goto addr_1000857c_40;
    }
    addr_100084a7_13:
    while (ecx13) {
        --ecx13;
        *reinterpret_cast<void***>(edi10) = *reinterpret_cast<void***>(esi8);
        edi10 = edi10 + 4;
        esi8 = esi8 + 4;
    }
    goto *reinterpret_cast<int32_t*>(edx14 * 4 + 0x100085c0);
    addr_10008ddb_16:
    edx21 = 16 - eax15;
    v22 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx9) - edx21);
    eax23 = edx21;
    ecx24 = eax23 & 3;
    if (ecx24) {
        do {
            *reinterpret_cast<void***>(edi10) = *reinterpret_cast<void***>(esi8);
            ++esi8;
            ++edi10;
            --ecx24;
        } while (ecx24);
    }
    eax25 = eax23 >> 2;
    if (eax25) {
        do {
            *reinterpret_cast<void***>(edi10) = *reinterpret_cast<void***>(esi8);
            esi8 = esi8 + 4;
            edi10 = edi10 + 4;
            --eax25;
        } while (eax25);
    }
    ecx9 = v22;
    addr_10008d1a_17:
    ecx26 = reinterpret_cast<unsigned char>(ecx9) & 0x7f;
    edx27 = reinterpret_cast<unsigned char>(ecx9) >> 7;
    if (edx27) {
        do {
            __asm__("movdqa xmm0, [esi]");
            __asm__("movdqa xmm1, [esi+0x10]");
            __asm__("movdqa xmm2, [esi+0x20]");
            __asm__("movdqa xmm3, [esi+0x30]");
            __asm__("movdqa [edi], xmm0");
            __asm__("movdqa [edi+0x10], xmm1");
            __asm__("movdqa [edi+0x20], xmm2");
            __asm__("movdqa [edi+0x30], xmm3");
            __asm__("movdqa xmm4, [esi+0x40]");
            __asm__("movdqa xmm5, [esi+0x50]");
            __asm__("movdqa xmm6, [esi+0x60]");
            __asm__("movdqa xmm7, [esi+0x70]");
            __asm__("movdqa [edi+0x40], xmm4");
            __asm__("movdqa [edi+0x50], xmm5");
            __asm__("movdqa [edi+0x60], xmm6");
            __asm__("movdqa [edi+0x70], xmm7");
            esi8 = esi8 + 0x80;
            edi10 = edi10 + 0x80;
            --edx27;
        } while (edx27);
    }
    if (ecx26) {
        edx28 = ecx26 >> 4;
        if (edx28) {
            do {
                __asm__("movdqa xmm0, [esi]");
                __asm__("movdqa [edi], xmm0");
                esi8 = esi8 + 16;
                edi10 = edi10 + 16;
                --edx28;
            } while (edx28);
        }
        ecx29 = ecx26 & 15;
        if (ecx29) {
            eax30 = ecx29;
            ecx31 = ecx29 >> 2;
            if (ecx31) {
                do {
                    *reinterpret_cast<void***>(edi10) = *reinterpret_cast<void***>(esi8);
                    esi8 = esi8 + 4;
                    edi10 = edi10 + 4;
                    --ecx31;
                } while (ecx31);
            }
            ecx32 = eax30 & 3;
            if (ecx32) {
                do {
                    *reinterpret_cast<void***>(edi10) = *reinterpret_cast<void***>(esi8);
                    ++esi8;
                    ++edi10;
                    --ecx32;
                } while (ecx32);
            }
        }
    }
    goto 3;
    goto 3;
    *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(edi17) + 3) = *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(esi16) + 3);
    goto 3;
    *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(edi17) + 3) = *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(esi16) + 3);
    *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(edi17) + 2) = *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(esi16) + 2);
    goto 3;
    *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(edi17) + 3) = *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(esi16) + 3);
    *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(edi17) + 2) = *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(esi16) + 2);
    *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(edi17) + 1) = *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(esi16) + 1);
    goto 3;
}

int32_t fun_10007690() {
    void** v1;

    v1 = g1000e498;
    DecodePointer();
    goto v1;
}

int32_t g1000a694 = 12;

void** fun_10007659(void** a1) {
    void** eax2;
    int32_t ecx3;
    void** edx4;
    void** edx5;

    eax2 = a1;
    ecx3 = g1000a694;
    do {
        if (*reinterpret_cast<void***>(eax2 + 4) == edx4) 
            break;
        eax2 = eax2 + 12;
    } while (reinterpret_cast<unsigned char>(eax2) < reinterpret_cast<unsigned char>(a1 + ecx3 * 12));
    if (reinterpret_cast<unsigned char>(eax2) >= reinterpret_cast<unsigned char>(a1 + ecx3 * 12) || *reinterpret_cast<void***>(eax2 + 4) != edx5) {
        eax2 = reinterpret_cast<void**>(0);
    }
    return eax2;
}

void fun_10007804(void** ecx) {
    int32_t ebp2;

    if (*reinterpret_cast<int32_t*>(ebp2 - 28)) {
        fun_10006d18(ecx, 0);
    }
    return;
}

int32_t SetStdHandle = 0xcd22;

uint32_t fun_10007c58(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
    int1_t cf7;
    uint32_t** edi8;
    uint32_t esi9;
    void** edi10;
    void** esi11;
    void** ebx12;
    void** ebp13;
    void** eax14;
    void** eax15;
    uint32_t eax16;
    int1_t zf17;
    void** ecx18;
    int32_t v19;
    void** ecx20;

    if (reinterpret_cast<signed char>(a2) < reinterpret_cast<signed char>(0) || ((cf7 = reinterpret_cast<unsigned char>(a2) < reinterpret_cast<unsigned char>(g1000fb2c), !cf7) || ((edi8 = reinterpret_cast<uint32_t**>((reinterpret_cast<signed char>(a2) >> 5) * 4 + 0x1000fb40), esi9 = (reinterpret_cast<unsigned char>(a2) & 31) << 6, (*reinterpret_cast<unsigned char*>(reinterpret_cast<int32_t>(*edi8) + esi9 + 4) & 1) == 0) || *reinterpret_cast<uint32_t*>(reinterpret_cast<int32_t>(*edi8) + esi9) == 0xffffffff))) {
        eax14 = fun_10002896(a2, edi10, esi11, ebx12, ebp13, __return_address(), a2, a3, a4, a5, a6);
        *reinterpret_cast<void***>(eax14) = reinterpret_cast<void**>(9);
        eax15 = fun_100028a9(a2, edi10, esi11, ebx12, ebp13, __return_address(), a2, a3, a4, a5);
        *reinterpret_cast<void***>(eax15) = reinterpret_cast<void**>(0);
        eax16 = 0xffffffff;
    } else {
        zf17 = g1000de30 == 1;
        if (!zf17) 
            goto addr_10007cba_4;
        ecx18 = reinterpret_cast<void**>(static_cast<uint32_t>(reinterpret_cast<unsigned char>(a2)));
        if (!ecx18) 
            goto addr_10007cb1_6; else 
            goto addr_10007ca1_7;
    }
    addr_10007cd9_8:
    return eax16;
    addr_10007cb1_6:
    v19 = 0xf6;
    addr_10007cb4_9:
    SetStdHandle(v19, 0);
    goto addr_10007cba_4;
    addr_10007ca1_7:
    ecx20 = ecx18 - 1;
    if (!ecx20) {
        v19 = 0xf5;
        goto addr_10007cb4_9;
    } else {
        if (ecx20 - 1) {
            addr_10007cba_4:
            *reinterpret_cast<uint32_t*>(esi9 + reinterpret_cast<int32_t>(*edi8)) = 0xffffffff;
            eax16 = 0;
            goto addr_10007cd9_8;
        } else {
            v19 = 0xf4;
            goto addr_10007cb4_9;
        }
    }
}

void fun_10007ddd(void** ecx) {
    fun_10006d18(ecx, 10);
    return;
}

void fun_1000819a(void** ecx) {
    void** eax2;
    void** v3;
    int32_t esi4;
    struct s95* esi5;

    eax2 = g1000eb04;
    v3 = *reinterpret_cast<void***>(eax2 + esi4 * 4);
    fun_1000583c(esi5, v3);
    return;
}

uint32_t fun_10008b52(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14) {
    uint32_t edi15;
    uint32_t eax16;
    void** edi17;
    void** esi18;
    void** ebp19;
    void** eax20;
    int32_t eax21;
    void** v22;
    uint32_t eax23;
    void** eax24;

    edi15 = 0xffffffff;
    if (a2) {
        if (reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a2 + 12)) & 0x83) {
            eax16 = fun_10008048(a2);
            edi15 = eax16;
            fun_10008f6f(ecx, a2, a2, edi17, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
            eax20 = fun_1000586b(ecx, a2, a2, a2, edi17, esi18, ebp19, __return_address(), a2);
            eax21 = fun_10008eab(ecx, eax20, a2, a2, a2, edi17, esi18, ebp19);
            if (eax21 >= 0) {
                if (*reinterpret_cast<void***>(a2 + 28)) {
                    v22 = *reinterpret_cast<void***>(a2 + 28);
                    fun_10002416(ecx, v22, edi17, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
                    *reinterpret_cast<void***>(a2 + 28) = reinterpret_cast<void**>(0);
                }
            } else {
                edi15 = 0xffffffff;
            }
        }
        *reinterpret_cast<void***>(a2 + 12) = reinterpret_cast<void**>(0);
        eax23 = edi15;
    } else {
        eax24 = fun_10002896(ecx, edi17, esi18, ebp19, __return_address(), a2, a3, a4, a5, a6, a7);
        *reinterpret_cast<void***>(eax24) = reinterpret_cast<void**>(22);
        fun_10002844(ecx);
        eax23 = 0xffffffff;
    }
    return eax23;
}

void fun_10008d04(void** ecx) {
    int32_t ebx2;

    fun_10007de6(ebx2);
    return;
}

void fun_10008f67(void** ecx) {
    int32_t ebx2;

    fun_10007de6(ebx2);
    return;
}

void** fun_100092de(void** a1, void** a2) {
    void** eax3;
    void** ecx4;

    eax3 = reinterpret_cast<void**>(0);
    if (reinterpret_cast<unsigned char>(a2) > reinterpret_cast<unsigned char>(0)) {
        ecx4 = a1;
        do {
            if (!*reinterpret_cast<void***>(ecx4)) 
                break;
            ++eax3;
            ++ecx4;
        } while (reinterpret_cast<unsigned char>(eax3) < reinterpret_cast<unsigned char>(a2));
    }
    return eax3;
}

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

struct s104 {
    signed char[112] pad112;
    uint32_t f112;
};

void** fun_1000924c(void** a1, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9) {
    void** ecx10;
    void** edi11;
    void** ebx12;
    void** v13;
    void** v14;
    void** v15;
    void** v16;
    void** ebp17;
    void** v18;
    void** v19;
    void** v20;
    void** v21;
    void** eax22;
    signed char v23;
    struct s104* v24;

    ecx10 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 + 0xfffffff0);
    fun_10001d91(ecx10, a3, edi11, ebx12, v13, v14, v15, v16, ebp17, __return_address(), a1);
    eax22 = fun_100090d8(ecx10, a2, edi11, ebx12, v18, v19, v20, v21, ebp17, __return_address(), a1, a2, a3, a4, a5, a6, a7, a8, a9);
    if (v23) {
        v24->f112 = v24->f112 & 0xfffffffd;
    }
    return eax22;
}

int32_t HidD_GetHidGuid = 0xc826;

int32_t SetupDiGetClassDevsW = 0xc878;

int32_t SetupDiEnumDeviceInterfaces = 0xc890;

int32_t SetupDiDestroyDeviceInfoList = 0xc858;

int32_t SetupDiGetDeviceInterfaceDetailW = 0xc8ae;

void** fun_10001140(void** ecx, void* a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12) {
    int32_t* esp13;
    int32_t edi14;
    int32_t esi15;
    int32_t ebx16;
    void** eax17;
    void* esp18;
    void** edi19;
    void** ecx20;
    uint32_t v21;
    void** eax22;
    void** v23;
    void* esp24;
    void** v25;
    void** v26;
    int32_t eax27;
    void* esp28;
    void** ecx29;
    uint32_t v30;
    void** eax31;
    int32_t esi32;
    void* esp33;
    void** v34;
    void* esp35;
    void** v36;
    void** eax37;
    void*** esp38;
    void** ecx39;
    int32_t eax40;
    void* esp41;
    void** esi42;
    void* esp43;
    void** v44;
    void* esp45;
    void* esp46;
    void** ecx47;
    void** eax48;
    void** eax49;
    void** eax50;
    void** eax51;
    void** eax52;
    void** eax53;
    void* esp54;
    void* eax55;
    void* v56;
    void** esp57;
    void* v58;
    int32_t eax59;
    void** ecx60;
    uint32_t v61;
    void** eax62;

    esp13 = reinterpret_cast<int32_t*>((reinterpret_cast<uint32_t>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4) & 0xfffffff8) - 0x14c - 4 - 4 - 4);
    HidD_GetHidGuid(esp13 + 7, edi14, esi15, ebx16, 0);
    eax17 = reinterpret_cast<void**>(SetupDiGetClassDevsW());
    esp18 = reinterpret_cast<void*>(esp13 - 1 - 1 + 1 - 1 - 1 - 1 - 1 - 1 + 1);
    edi19 = eax17;
    if (!edi19) {
        addr_10001317_2:
        ecx20 = reinterpret_cast<void**>(v21 ^ reinterpret_cast<uint32_t>(esp18) + 4 + 4 + 4);
        eax22 = fun_10001cc4(ecx20, 18, ecx20, 18);
        return eax22;
    } else {
        v23 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp18) + 44);
        esp24 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp18) - 4 - 4);
        v25 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp24) + 36);
        v26 = edi19;
        eax27 = reinterpret_cast<int32_t>(SetupDiEnumDeviceInterfaces());
        GetLastError();
        esp28 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp24) - 4 - 4 - 4 - 4 + 4 - 4 + 4);
        if (!eax27) {
            addr_100012e9_4:
            SetupDiDestroyDeviceInfoList();
            ecx29 = reinterpret_cast<void**>(v30 ^ reinterpret_cast<uint32_t>(esp28) - 4 - 4 + 4 + 4 + 4 + 4);
            eax31 = fun_10001cc4(ecx29, v25, ecx29, v25);
            return eax31;
        } else {
            do {
                esi32 = SetupDiGetDeviceInterfaceDetailW;
                esp33 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp28) - 4);
                v34 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp33) + 20);
                esp35 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp33) - 4 - 4 - 4);
                v36 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp35) + 60);
                esi32();
                eax37 = fun_10001cae(v34, edi19, v36, 0, 0, v34, 0, v26, 0, v25, 0, v23);
                *reinterpret_cast<void***>(eax37) = reinterpret_cast<void**>(6);
                esp38 = reinterpret_cast<void***>(reinterpret_cast<uint32_t>(esp35) - 4 - 4 - 4 + 4 - 4 - 4 + 4 + 4 - 4 - 4 - 4 - 4);
                ecx39 = reinterpret_cast<void**>(esp38 + 60);
                eax40 = reinterpret_cast<int32_t>(esi32(edi19, ecx39, eax37));
                esp41 = reinterpret_cast<void*>(esp38 - 4 - 4 - 4 + 4);
                if (!eax40) 
                    break;
                esi42 = eax37 + 4;
                esp43 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp41) - 4 - 4);
                v44 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp43) + 80);
                fun_10001cd3(ecx39, v44, 0x104, "%S", esi42, edi19, ecx39, eax37, v34, 0, 0);
                esp45 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp43) - 4 - 4 - 4 + 4 - 4);
                fun_1000207f(ecx39, reinterpret_cast<uint32_t>(esp45) + 92, esi42, 0x104, v44, 0x104, "%S", esi42, edi19, ecx39, eax37);
                esp46 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp45) - 4 - 4 - 4 + 4 + 28);
                if (edi19 && (!1 && ((ecx47 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp46) + 72), eax48 = fun_10009281(ecx47, ecx47, edi19, ecx39, eax37, v34, 0, 0, edi19, v36, 0, 0), eax49 = fun_10001d00(eax48, edi19, edi19, ecx39, eax37), esp46 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp46) - 4 - 4 + 4 + 4 - 4 - 4 - 4 + 4 + 8), !!eax49) && ((eax50 = fun_10009281(ecx47, reinterpret_cast<uint32_t>(esp46) + 72, edi19, ecx39, eax37, v34, 0, 0, edi19, v36, 0, 0), eax51 = fun_10001d00(eax50, 0, edi19, ecx39, eax37), esp46 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp46) - 4 - 4 + 4 + 4 - 4 - 4 - 4 + 4 + 8), !!eax51) && (eax52 = reinterpret_cast<void**>(CreateFileW()), esp46 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp46) - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 + 4), eax52 != 0xffffffff))))) {
                    eax53 = fun_10001000(eax52);
                    esp54 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp46) - 4 - 4 + 4 + 4);
                    if (eax53) 
                        goto addr_1000132e_8;
                    CloseHandle(eax52);
                    esp46 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp54) - 4 - 4 + 4);
                }
                eax55 = reinterpret_cast<void*>(v34 + 1);
                v56 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp46) + 44);
                esp57 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esp46) - 4 - 4);
                v58 = reinterpret_cast<void*>(esp57 + 9);
                eax59 = reinterpret_cast<int32_t>(SetupDiEnumDeviceInterfaces(edi19, 0, v58, eax55, v56, edi19, ecx39, eax37, eax55, 0));
                GetLastError(edi19, 0, v58, eax55, v56, edi19, ecx39, eax37, eax55, 0);
                esp28 = reinterpret_cast<void*>(esp57 - 1 - 1 - 1 - 1 + 1 - 1 + 1);
            } while (eax59);
            goto addr_100012e9_4;
        }
    }
    SetupDiDestroyDeviceInfoList(edi19, edi19, ecx39, eax37);
    fun_10001d86(ecx39, eax37, edi19, edi19, ecx39, eax37, v34, 0, 0, edi19, v36, 0, 0, v34, 0);
    esp18 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esp41) - 4 - 4 + 4 - 4 - 4 + 4 + 4);
    goto addr_10001317_2;
    addr_1000132e_8:
    fun_10001d86(0, eax37, esi42, 0, 3, 0, 3, 0, 0, edi19, ecx39, eax37, v34, 0, 0);
    SetupDiDestroyDeviceInfoList();
    ecx60 = reinterpret_cast<void**>(v61 ^ reinterpret_cast<uint32_t>(esp54) - 4 - 4 + 4 + 4 - 4 - 4 + 4 + 4 + 4 + 4);
    eax62 = fun_10001cc4(ecx60, 3, ecx60, 3);
    return eax62;
}

void** fun_100048a9(void** ecx, void** a2, void** a3, void** a4) {
    void** ebp5;
    void** eax6;

    if (!reinterpret_cast<int1_t>(a2 == 0xe06d7363)) {
        return 0;
    } else {
        eax6 = fun_1000475f(ecx, 0xe06d7363, a3, ebp5, __return_address(), a2, a3, a4);
        return eax6;
    }
}

void fun_10003c0a(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9) {
    fun_10006df1(ecx, 8, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9);
    return;
}

void fun_10004b9b(void** ecx) {
    fun_10003c13(ecx);
    return;
}

void fun_10002dac(void** ecx) {
    fun_10006d18(ecx, 13);
    return;
}

struct s105 {
    signed char[16] pad16;
    int32_t f16;
};

void fun_10003e35(void** ecx) {
    struct s105* ebp2;

    if (ebp2->f16) {
        fun_10006d18(ecx, 8);
    }
    return;
}

int32_t RtlUnwind = 0xccd6;

void fun_100090d2() {
    goto RtlUnwind;
}

void fun_10007de6(int32_t a1) {
    int32_t ebp2;

    LeaveCriticalSection();
    goto ebp2;
}

void fun_1000803f(void** ecx) {
    fun_10006d18(ecx, 1);
    return;
}

void fun_10008c2b(void** ecx) {
    void** esi2;

    fun_10005800(esi2);
    return;
}

struct s106 {
    signed char[4] pad4;
    void** f4;
    signed char[15] pad20;
    void** f20;
};

struct s107 {
    signed char[4] pad4;
    void** f4;
    signed char[15] pad20;
    void** f20;
};

void** fun_100090d8(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void** a16, void** a17, void** a18, void** a19) {
    void*** esp20;
    void*** ebp21;
    void** eax22;
    void** v23;
    void** v24;
    void** esi25;
    void** edi26;
    void** eax27;
    struct s106* eax28;
    struct s106** ebx29;
    void** ecx30;
    void** v31;
    void** ebx32;
    void** v33;
    void** v34;
    void** ebp35;
    void** eax36;
    void** v37;
    void** v38;
    void** eax39;
    void** v40;
    void** eax41;
    void** v42;
    void** v43;
    void** eax44;
    void** v45;
    void** v46;
    void** eax47;
    void** ecx48;
    void** v49;
    void** v50;
    struct s107* eax51;
    struct s107** ebx52;
    void** v53;
    void** v54;
    void** ebx55;
    void** eax56;
    void** eax57;
    void** eax58;
    void** eax59;

    esp20 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    ebp21 = esp20;
    eax22 = g1000d050;
    v23 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax22) ^ reinterpret_cast<uint32_t>(ebp21));
    v24 = esi25;
    if (edi26) {
        eax27 = fun_100092de(edi26, a2);
        ecx = a2;
        if (reinterpret_cast<unsigned char>(eax27) < reinterpret_cast<unsigned char>(a2)) {
            eax28 = *ebx29;
            ecx30 = eax28->f20;
            if (ecx30) {
                v31 = eax28->f4;
                eax36 = fun_10006b0a(ebx32, ecx30, 0x200, edi26, 0xff, 0, 0, v31, 1, v24, v33, v34, v23, ebp35, __return_address(), a2, a3);
                ecx = eax36;
                v37 = ecx;
                if (ecx) {
                    if (reinterpret_cast<unsigned char>(a2) >= reinterpret_cast<unsigned char>(ecx)) {
                        if (reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(ecx) < reinterpret_cast<signed char>(0)) | reinterpret_cast<uint1_t>(ecx == 0) || 0xe0 / reinterpret_cast<unsigned char>(ecx) < 1) {
                            v38 = reinterpret_cast<void**>(0);
                        } else {
                            eax39 = ecx + 8;
                            if (reinterpret_cast<unsigned char>(eax39) > reinterpret_cast<unsigned char>(0x400)) {
                                eax41 = fun_10004bb8(ecx, eax39, v24, v37, v40, v23, ebp35, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
                                if (!eax41) {
                                    addr_100091d4_10:
                                    ecx = v37;
                                    v38 = eax41;
                                } else {
                                    *reinterpret_cast<void***>(eax41) = reinterpret_cast<void**>(0xdddd);
                                    goto addr_100091d1_12;
                                }
                            } else {
                                fun_100082b0(ecx, v24, v37, v42, v23, ebp35, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
                                eax41 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(reinterpret_cast<unsigned char>(esp20 - 12 - 4 - 4 - 4 - 4 + 4 + 4 + 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 - 4 + 4 + 36) - 4 + 4) - 4 + 4);
                                if (!eax41) 
                                    goto addr_100091d4_10;
                                v24 = reinterpret_cast<void**>(0xcccc);
                                goto addr_100091d1_12;
                            }
                        }
                    } else {
                        *reinterpret_cast<void***>(edi26) = reinterpret_cast<void**>(0);
                        eax44 = fun_10002896(ecx, v24, v37, v43, v23, ebp35, __return_address(), a2, a3, a4, a5);
                        v45 = reinterpret_cast<void**>(34);
                        goto addr_100090f6_16;
                    }
                } else {
                    eax47 = fun_10002896(ecx, v24, v37, v46, v23, ebp35, __return_address(), a2, a3, a4, a5);
                    *reinterpret_cast<void***>(eax47) = reinterpret_cast<void**>(42);
                    goto addr_10009173_18;
                }
            } else {
                ecx48 = edi26;
                if (*reinterpret_cast<void***>(edi26)) {
                    do {
                        if (reinterpret_cast<signed char>(*reinterpret_cast<void***>(ecx48)) >= reinterpret_cast<signed char>(97) && reinterpret_cast<signed char>(*reinterpret_cast<void***>(ecx48)) <= reinterpret_cast<signed char>(0x7a)) {
                            *reinterpret_cast<void***>(ecx48) = *reinterpret_cast<void***>(ecx48) - 32;
                        }
                        ++ecx48;
                    } while (*reinterpret_cast<void***>(ecx48));
                }
                goto addr_1000923c_24;
            }
        } else {
            *reinterpret_cast<void***>(edi26) = reinterpret_cast<void**>(0);
            goto addr_100090ef_26;
        }
    } else {
        addr_100090ef_26:
        eax44 = fun_10002896(ecx, v24, v49, v50, v23, ebp35, __return_address(), a2, a3, a4, a5);
        v45 = reinterpret_cast<void**>(22);
        goto addr_100090f6_16;
    }
    if (v38) {
        eax51 = *ebx52;
        v53 = eax51->f4;
        v54 = eax51->f20;
        eax56 = fun_10006b0a(ebx55, v54, 0x200, edi26, 0xff, v38, ecx, v53, 1, v24, v37, v38, v23, ebp35, __return_address(), a2, a3);
        if (!eax56) {
            eax57 = fun_10002896(ecx, v24, v37, v38, v23, ebp35, __return_address(), a2, a3, a4, a5);
            ecx = reinterpret_cast<void**>(42);
            *reinterpret_cast<void***>(eax57) = reinterpret_cast<void**>(42);
        } else {
            fun_10007302(ecx, edi26, a2, v38, v24, v37, v38);
        }
        fun_10006903(ecx, v38, v24, v37, v38, v23, ebp35, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19);
    } else {
        eax58 = fun_10002896(ecx, v24, v37, v38, v23, ebp35, __return_address(), a2, a3, a4, a5);
        *reinterpret_cast<void***>(eax58) = reinterpret_cast<void**>(12);
        goto addr_10009173_18;
    }
    addr_1000923a_33:
    addr_1000923c_24:
    eax59 = fun_10001cc4(reinterpret_cast<unsigned char>(v23) ^ reinterpret_cast<uint32_t>(ebp21), v37);
    return eax59;
    addr_10009173_18:
    fun_10002896(ecx, v24, v37, v38, v23, ebp35, __return_address(), a2, a3, a4, a5);
    goto addr_1000923c_24;
    addr_100091d1_12:
    eax41 = eax41 + 8;
    goto addr_100091d4_10;
    addr_100090f6_16:
    *reinterpret_cast<void***>(eax44) = v45;
    fun_10002844(ecx);
    goto addr_1000923a_33;
}

struct s108 {
    signed char[1] pad1;
    signed char f1;
};

struct s109 {
    signed char[1] pad1;
    signed char f1;
};

struct s110 {
    signed char[2] pad2;
    signed char f2;
};

struct s111 {
    signed char[2] pad2;
    signed char f2;
};

struct s112 {
    signed char[3] pad3;
    int32_t f3;
};

struct s113 {
    signed char[3] pad3;
    int32_t f3;
};

void fun_100084e4(uint32_t ecx) {
    uint32_t edx2;
    uint32_t edx3;
    signed char* edi4;
    signed char* esi5;
    struct s108* edi6;
    struct s109* esi7;
    uint32_t ecx8;
    struct s110* edi9;
    struct s111* esi10;
    int32_t* esi11;
    struct s112* esi12;
    int32_t* edi13;
    struct s113* edi14;

    edx2 = edx3 & ecx;
    *edi4 = *esi5;
    edi6->f1 = esi7->f1;
    ecx8 = ecx >> 2;
    edi9->f2 = esi10->f2;
    esi11 = &esi12->f3;
    edi13 = &edi14->f3;
    if (ecx8 < 8) 
        goto 0x100084d0;
    while (ecx8) {
        --ecx8;
        *edi13 = *esi11;
        ++edi13;
        ++esi11;
    }
    switch (edx2) {
    case 3:
        goto 0x100085f8;
    case 2:
        goto 0x100085e4;
    case 1:
        goto 0x100085d8;
    case 0:
        goto 0x100085d0;
    }
}

struct s114 {
    signed char[3] pad3;
    signed char f3;
};

struct s115 {
    signed char[3] pad3;
    signed char f3;
};

void fun_10008670(uint32_t ecx) {
    uint32_t edx2;
    uint32_t edx3;
    struct s114* edi4;
    struct s115* esi5;
    int32_t* esi6;
    void* esi7;
    uint32_t ecx8;
    int32_t* edi9;
    void* edi10;

    edx2 = edx3 & ecx;
    edi4->f3 = esi5->f3;
    esi6 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esi7) - 1);
    ecx8 = ecx >> 2;
    edi9 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(edi10) - 1);
    if (ecx8 < 8) 
        goto 0x10008638;
    while (ecx8) {
        --ecx8;
        *edi9 = *esi6;
        --edi9;
        --esi6;
    }
    switch (edx2) {
    case 3:
        goto 0x10008798;
    case 2:
        goto 0x10008784;
    case 1:
        goto 0x10008774;
    case 0:
        goto 0x1000876c;
    }
}

void fun_10008710(int32_t ecx) {
    void* edi2;
    void* esi3;
    void* edi4;
    void* esi5;
    void* edi6;
    void* esi7;
    void* edi8;
    void* esi9;
    void* edi10;
    void* esi11;
    void* edi12;
    void* esi13;
    void* edi14;
    void* esi15;

    *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(edi2) + ecx * 4 + 28) = *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esi3) + ecx * 4 + 28);
    *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(edi4) + ecx * 4 + 24) = *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esi5) + ecx * 4 + 24);
    *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(edi6) + ecx * 4 + 20) = *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esi7) + ecx * 4 + 20);
    *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(edi8) + ecx * 4 + 16) = *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esi9) + ecx * 4 + 16);
    *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(edi10) + ecx * 4 + 12) = *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esi11) + ecx * 4 + 12);
    *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(edi12) + ecx * 4 + 8) = *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esi13) + ecx * 4 + 8);
    *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(edi14) + ecx * 4 + 4) = *reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esi15) + ecx * 4 + 4);
}

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

void fun_10001588(int32_t ecx, int32_t a2, void** a3, void** a4) {
    void** v5;
    int32_t ebp6;
    int32_t eax7;
    int32_t ebp8;
    int32_t ebp9;
    int32_t ebp10;
    int32_t ebp11;
    int32_t ebp12;
    int32_t ebp13;
    int32_t ebx14;
    uint32_t esi15;
    int32_t ecx16;
    int32_t ebp17;
    int32_t edi18;
    uint32_t edx19;
    uint32_t edx20;
    uint32_t edx21;
    uint32_t eax22;
    int32_t ebp23;
    int32_t ebp24;
    uint32_t eax25;
    int32_t ebp26;
    signed char dl27;
    int32_t ebp28;
    int32_t ebp29;
    int32_t ebp30;
    int32_t ebp31;
    int32_t ebp32;
    void** esi33;
    void* ebp34;
    int32_t edi35;
    int32_t ebp36;
    signed char bl37;
    void* ebp38;
    void** v39;
    void* ebp40;
    void** ecx41;
    int32_t ebp42;
    uint32_t ebp43;
    struct s116* ebp44;

    v5 = reinterpret_cast<void**>(__return_address());
    do {
        *reinterpret_cast<int32_t*>(ebp6 + eax7 * 4 - 0x5a8) = ecx;
        *reinterpret_cast<int32_t*>(ebp8 + eax7 * 4 - 0x550) = ecx;
        *reinterpret_cast<int32_t*>(ebp9 + eax7 * 4 - 0x4f8) = ecx;
        *reinterpret_cast<int32_t*>(ebp10 + eax7 * 4 - 0x4a0) = ecx;
        *reinterpret_cast<int32_t*>(ebp11 + eax7 * 4 - 0x448) = ecx;
        *reinterpret_cast<int32_t*>(ebp12 + eax7 * 4 - 0x3f0) = ecx;
        ++eax7;
    } while (eax7 < 22);
    *reinterpret_cast<int32_t*>(ebp13 - 0x5ac) = ebx14;
    esi15 = 0;
    do {
        ecx16 = *reinterpret_cast<int32_t*>(ebp17 - 0x5ac);
        edi18 = 0;
        do {
            if (edi18 < 54) {
                edx19 = (__intrinsic() >> 1) + esi15;
                edx20 = edx19 + edx19;
                edx21 = edx20 + edx20;
                eax22 = *reinterpret_cast<unsigned char*>(ebp23 + edx21 - 0x5a8);
                *reinterpret_cast<signed char*>(ebp24 + ecx16 - 0xce) = *reinterpret_cast<signed char*>(&eax22);
                eax25 = *reinterpret_cast<unsigned char*>(ebp26 + edx21 - 0x5a7);
                dl27 = *reinterpret_cast<signed char*>(ebp28 + edx21 - 0x5a6);
                *reinterpret_cast<signed char*>(ebp29 + ecx16 - 0xcd) = *reinterpret_cast<signed char*>(&eax25);
                *reinterpret_cast<signed char*>(ebp30 + ecx16 - 0xcc) = dl27;
            }
            edi18 = edi18 + 3;
            ecx16 = ecx16 + 3;
        } while (edi18 < 64);
        *reinterpret_cast<int32_t*>(ebp31 - 0x5ac) = *reinterpret_cast<int32_t*>(ebp32 - 0x5ac) - 64;
        esi15 = esi15 + 22;
    } while (reinterpret_cast<int32_t>(esi15) < reinterpret_cast<int32_t>(0x84));
    esi33 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(ebp34) + 0xfffffde8);
    edi35 = 6;
    do {
        *reinterpret_cast<signed char*>(ebp36 - 0x98) = bl37;
        fun_10008450(reinterpret_cast<int32_t>(ebp38) + 0xffffff69, esi33, 64, v5, a2, a3, a4);
        v39 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(ebp40) + 0xffffff68);
        HidD_SetFeature();
        Sleep();
        esi33 = esi33 + 64;
        --edi35;
    } while (edi35);
    CloseHandle();
    ecx41 = reinterpret_cast<void**>(*reinterpret_cast<uint32_t*>(ebp42 - 4) ^ ebp43);
    fun_10001cc4(ecx41, v39, ecx41, v39);
    goto ebp44->f4;
}

void fun_100015ca() {
}

void fun_100021a1() {
}

void fun_10002347(int32_t* ecx) {
    *ecx = reinterpret_cast<int32_t>("R#");
    goto fun_10004a27;
}

void** fun_10002379(void** ecx, void** a2, void** a3, void** a4) {
    void** esi5;
    void** ebp6;

    fun_10004a59(ecx, a2, esi5, ebp6, __return_address(), a2, a3, a4);
    *reinterpret_cast<void***>(ecx) = reinterpret_cast<void**>("R#");
    return ecx;
}

void fun_1000362c() {
}

void fun_10004513() {
    int32_t* edi1;
    int32_t eax2;

    edi1 = reinterpret_cast<int32_t*>(0x1000c328);
    if (!1) {
        do {
            eax2 = *edi1;
            if (eax2) {
                eax2();
            }
            ++edi1;
        } while (reinterpret_cast<uint32_t>(edi1) < 0x1000c328);
    }
    return;
}

void** fun_1000576d(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13, void** a14, void** a15, void** a16, void** a17) {
    int1_t zf18;
    void** v19;
    void** eax20;

    fun_100081d2(ecx, __return_address(), a2, a3, a4);
    zf18 = g1000e1d0 == 0;
    if (!zf18) {
        fun_10007fac(ecx, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
    }
    v19 = g1000eb04;
    eax20 = fun_10002416(ecx, v19, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17);
    return eax20;
}

struct s117 {
    signed char[24] pad24;
    void** f24;
    signed char[3] pad28;
    void** f28;
    signed char[11] pad40;
    void** f40;
};

void fun_10007446(struct s117* a1) {
    void** v2;
    void** v3;
    void** v4;

    v2 = a1->f28;
    v3 = a1->f24;
    v4 = a1->f40;
    fun_10007370(v4, v3, v2);
    return;
}

int32_t fun_10007611() {
    return 1;
}

void fun_100077fe() {
}

int32_t fun_1000797b() {
    int32_t edx1;
    int32_t ebp2;

    edx1 = 0;
    *reinterpret_cast<unsigned char*>(&edx1) = reinterpret_cast<uint1_t>(***reinterpret_cast<int32_t***>(ebp2 - 20) == 0xc0000005);
    return edx1;
}

void fun_10007dd8() {
}

void fun_10008241(int32_t ecx) {
}

int32_t IsProcessorFeaturePresent = 0xcd42;

void fun_1000829e() {
    int32_t eax1;

    eax1 = reinterpret_cast<int32_t>(IsProcessorFeaturePresent());
    g1000eb00 = eax1;
    goto 10;
}

struct s118 {
    signed char[1] pad1;
    signed char f1;
};

struct s119 {
    signed char[1] pad1;
    signed char f1;
};

struct s120 {
    signed char[2] pad2;
    int32_t f2;
};

struct s121 {
    signed char[2] pad2;
    int32_t f2;
};

void fun_1000850d(uint32_t ecx) {
    uint32_t edx2;
    uint32_t edx3;
    signed char* edi4;
    signed char* esi5;
    uint32_t ecx6;
    struct s118* edi7;
    struct s119* esi8;
    int32_t* esi9;
    struct s120* esi10;
    int32_t* edi11;
    struct s121* edi12;

    edx2 = edx3 & ecx;
    *edi4 = *esi5;
    ecx6 = ecx >> 2;
    edi7->f1 = esi8->f1;
    esi9 = &esi10->f2;
    edi11 = &edi12->f2;
    if (ecx6 < 8) 
        goto 0x100084d0;
    while (ecx6) {
        --ecx6;
        *edi11 = *esi9;
        ++edi11;
        ++esi9;
    }
    switch (edx2) {
    case 3:
        goto 0x100085f8;
    case 2:
        goto 0x100085e4;
    case 1:
        goto 0x100085d8;
    case 0:
        goto 0x100085d0;
    }
}

struct s122 {
    signed char[1] pad1;
    int32_t f1;
};

struct s123 {
    signed char[1] pad1;
    int32_t f1;
};

void fun_10008534(uint32_t ecx) {
    uint32_t edx2;
    uint32_t edx3;
    signed char* edi4;
    signed char* esi5;
    int32_t* esi6;
    struct s122* esi7;
    uint32_t ecx8;
    int32_t* edi9;
    struct s123* edi10;

    edx2 = edx3 & ecx;
    *edi4 = *esi5;
    esi6 = &esi7->f1;
    ecx8 = ecx >> 2;
    edi9 = &edi10->f1;
    if (ecx8 < 8) 
        goto 0x100084d0;
    while (ecx8) {
        --ecx8;
        *edi9 = *esi6;
        ++edi9;
        ++esi6;
    }
    switch (edx2) {
    case 3:
        goto 0x100085f8;
    case 2:
        goto 0x100085e4;
    case 1:
        goto 0x100085d8;
    case 0:
        goto 0x100085d0;
    }
}

void fun_10008551(int32_t ecx) {
}

void fun_100085be() {
}

void fun_10008636() {
}

struct s124 {
    signed char[3] pad3;
    signed char f3;
};

struct s125 {
    signed char[3] pad3;
    signed char f3;
};

struct s126 {
    signed char[2] pad2;
    signed char f2;
};

struct s127 {
    signed char[2] pad2;
    signed char f2;
};

void fun_10008691(uint32_t ecx) {
    uint32_t edx2;
    uint32_t edx3;
    struct s124* edi4;
    struct s125* esi5;
    uint32_t ecx6;
    struct s126* edi7;
    struct s127* esi8;
    int32_t* esi9;
    void* esi10;
    int32_t* edi11;
    void* edi12;

    edx2 = edx3 & ecx;
    edi4->f3 = esi5->f3;
    ecx6 = ecx >> 2;
    edi7->f2 = esi8->f2;
    esi9 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esi10) - 2);
    edi11 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(edi12) - 2);
    if (ecx6 < 8) 
        goto 0x10008638;
    while (ecx6) {
        --ecx6;
        *edi11 = *esi9;
        --edi11;
        --esi9;
    }
    switch (edx2) {
    case 3:
        goto 0x10008798;
    case 2:
        goto 0x10008784;
    case 1:
        goto 0x10008774;
    case 0:
        goto 0x1000876c;
    }
}

struct s128 {
    signed char[3] pad3;
    signed char f3;
};

struct s129 {
    signed char[3] pad3;
    signed char f3;
};

struct s130 {
    signed char[2] pad2;
    signed char f2;
};

struct s131 {
    signed char[2] pad2;
    signed char f2;
};

struct s132 {
    signed char[1] pad1;
    signed char f1;
};

struct s133 {
    signed char[1] pad1;
    signed char f1;
};

void fun_100086bc(uint32_t ecx) {
    uint32_t edx2;
    uint32_t edx3;
    struct s128* edi4;
    struct s129* esi5;
    struct s130* edi6;
    struct s131* esi7;
    uint32_t ecx8;
    struct s132* edi9;
    struct s133* esi10;
    int32_t* esi11;
    void* esi12;
    int32_t* edi13;
    void* edi14;

    edx2 = edx3 & ecx;
    edi4->f3 = esi5->f3;
    edi6->f2 = esi7->f2;
    ecx8 = ecx >> 2;
    edi9->f1 = esi10->f1;
    esi11 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(esi12) - 3);
    edi13 = reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(edi14) - 3);
    if (ecx8 < 8) 
        goto 0x10008638;
    while (ecx8) {
        --ecx8;
        *edi13 = *esi11;
        --edi13;
        --esi11;
    }
    switch (edx2) {
    case 3:
        goto 0x10008798;
    case 2:
        goto 0x10008784;
    case 1:
        goto 0x10008774;
    case 0:
        goto 0x1000876c;
    }
}

void fun_100086ed(int32_t ecx) {
}

void fun_1000875a() {
}

void fun_10008d26() {
}

void* fun_10008ff0(int32_t ecx, signed char* a2, signed char* a3) {
    void* eax4;
    signed char* edx5;
    signed char* esi6;

    eax4 = reinterpret_cast<void*>(0);
    edx5 = a3;
    while (*edx5) {
        ++edx5;
        __asm__("bts [esp], eax");
    }
    esi6 = a2;
    do {
        *reinterpret_cast<signed char*>(&eax4) = *esi6;
        if (!*reinterpret_cast<signed char*>(&eax4)) 
            break;
        ++esi6;
    } while (!static_cast<int1_t>(0 >> reinterpret_cast<int32_t>(eax4)));
    goto addr_10009027_7;
    addr_1000902a_8:
    return eax4;
    addr_10009027_7:
    eax4 = reinterpret_cast<void*>(esi6 - 1);
    goto addr_1000902a_8;
}

int32_t fun_10009030(int32_t a1, uint32_t a2, int32_t a3, uint32_t a4) {
    if (a4 | a2) {
        return a1 * a3;
    } else {
        return a1 * a3;
    }
}

void fun_100092fb() {
    g1000de34 = reinterpret_cast<int32_t>("R#");
    goto fun_10004a27;
}

void** SetLEDEffect(void** a1, void** a2, signed char a3, signed char a4, signed char a5, signed char a6) {
    void* ebp7;
    void** eax8;
    uint32_t v9;
    void** ecx10;
    void** edi11;
    void** ebx12;
    void** v13;
    void** v14;
    void** v15;
    void** v16;
    void** v17;
    void** ecx18;
    void** eax19;
    void** eax20;
    void** esi21;
    void** v22;
    void** v23;
    void** v24;
    void** v25;
    void** v26;
    void** ecx27;
    void** eax28;

    ebp7 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    eax8 = g1000d050;
    v9 = reinterpret_cast<unsigned char>(eax8) ^ reinterpret_cast<uint32_t>(ebp7);
    ecx10 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp7) + 0xffffffec);
    fun_10001cd3(ecx10, ecx10, 5, "%04X", a1, edi11, ebx12, v13, v14, v15, v16);
    v17 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp7) + 0xfffffff4);
    fun_10001cd3(ecx10, v17, 5, "%04X", a2, ecx10, 5, "%04X", a1, edi11, ebx12);
    ecx18 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp7) + 0xfffffff4);
    eax19 = fun_10001140(ecx18, reinterpret_cast<uint32_t>(ebp7) + 0xffffffec, v17, 5, "%04X", a2, ecx10, 5, "%04X", a1, edi11, ebx12);
    if (eax19 == 0xffffffff || !eax19) {
        CloseHandle(ecx18);
        eax20 = fun_10001cc4(v9 ^ reinterpret_cast<uint32_t>(ebp7), ebx12);
        return eax20;
    } else {
        fun_10005bc0(ecx18, reinterpret_cast<uint32_t>(ebp7) + 0xffffffa8, 0, 67, esi21, edi11, ebx12, v22, v23, v24, v25, v26);
        fun_10001070();
        CloseHandle();
        ecx27 = reinterpret_cast<void**>(v9 ^ reinterpret_cast<uint32_t>(ebp7));
        eax28 = fun_10001cc4(ecx27, ebx12, ecx27, ebx12);
        return eax28;
    }
}

void** g1000eafc;

void** SetSoftwareControlLEDEffect(void** a1, void** a2, int32_t a3) {
    void* ebp4;
    void** eax5;
    void** ecx6;
    void** esi7;
    void** ebx8;
    void** v9;
    void** v10;
    void** v11;
    void** v12;
    void** v13;
    void** ecx14;
    void** eax15;
    void** ecx16;
    void** eax17;
    int1_t zf18;
    void** v19;
    void** edi20;
    void** v21;
    void** v22;
    void** v23;
    void** v24;
    void* v25;
    int32_t edi26;
    void** v27;
    void** v28;
    void** v29;
    void** v30;
    int32_t ecx31;
    void* eax32;

    ebp4 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    eax5 = g1000d050;
    ecx6 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp4) + 0xffffffec);
    fun_10001cd3(ecx6, ecx6, 5, "%04X", a1, esi7, ebx8, v9, v10, v11, v12);
    v13 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp4) + 0xfffffff4);
    fun_10001cd3(ecx6, v13, 5, "%04X", a2, ecx6, 5, "%04X", a1, esi7, ebx8);
    ecx14 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp4) + 0xfffffff4);
    eax15 = fun_10001140(ecx14, reinterpret_cast<uint32_t>(ebp4) + 0xffffffec, v13, 5, "%04X", a2, ecx6, 5, "%04X", a1, esi7, ebx8);
    if (eax15 == 0xffffffff || !eax15) {
        CloseHandle(ecx14);
        ecx16 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax5) ^ reinterpret_cast<uint32_t>(ebp4) ^ reinterpret_cast<uint32_t>(ebp4));
        eax17 = fun_10001cc4(ecx16, ebx8, ecx16, ebx8);
        return eax17;
    } else {
        zf18 = g1000eafc == 0;
        if (zf18) {
            v19 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp4) + 0xffffffac);
            fun_10005bc0(ecx14, v19, 0, 64, edi20, esi7, ebx8, eax15, v21, v22, v23, v24);
            ecx14 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp4) + 0xffffff69);
            fun_10008450(ecx14, reinterpret_cast<uint32_t>(ebp4) + 0xffffffac, 64, v19, 0, 64, edi20);
            v25 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ebp4) + 0xffffff68);
            HidD_SetFeature(eax15, v25, 65, edi20);
            edi26 = Sleep;
            edi26(1, eax15, v25, 65, edi20);
            fun_100010d0(ecx14, 1, eax15, v25, 65, edi20);
            edi26(1, 1, eax15, v25, 65, edi20);
            g1000eafc = reinterpret_cast<void**>(1);
        }
        fun_10005bc0(ecx14, reinterpret_cast<uint32_t>(ebp4) + 0xfffffde9, 0, 0x17f, edi20, esi7, ebx8, eax15, v27, v28, v29, v30);
        ecx31 = 0;
        eax32 = reinterpret_cast<void*>(0);
        do {
            *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(ebp4) + reinterpret_cast<uint32_t>(eax32) + 0xfffffdf0) = *reinterpret_cast<signed char*>(&ecx31);
            *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(ebp4) + reinterpret_cast<uint32_t>(eax32) + 0xfffffde8) = 0x3a000000;
            *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(ebp4) + reinterpret_cast<uint32_t>(eax32) + 0xfffffdec) = 0x16060301;
            *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(ebp4) + reinterpret_cast<uint32_t>(eax32) + 0xfffffdf1) = 0;
            *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(ebp4) + reinterpret_cast<uint32_t>(eax32) + 0xfffffc6b) = 15;
            *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(ebp4) + reinterpret_cast<uint32_t>(eax32) + 0xfffffc6c) = 1;
            *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(ebp4) + reinterpret_cast<uint32_t>(eax32) + 0xfffffc6d) = 3;
            *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(ebp4) + reinterpret_cast<uint32_t>(eax32) + 0xfffffc6e) = 6;
            *reinterpret_cast<signed char*>(reinterpret_cast<uint32_t>(ebp4) + reinterpret_cast<uint32_t>(eax32) + 0xfffffc6f) = 22;
            eax32 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(eax32) + 64);
            ++ecx31;
        } while (reinterpret_cast<int32_t>(eax32) < reinterpret_cast<int32_t>(0x180));
        goto 0x10001590;
    }
}

void** SetLEDBackColor(void** a1, void** a2, signed char a3, signed char a4, signed char a5, signed char a6, signed char a7) {
    void* ebp8;
    void** eax9;
    uint32_t v10;
    void** ecx11;
    void** ebx12;
    void** v13;
    void** v14;
    void** v15;
    void** v16;
    void** v17;
    void** v18;
    void** v19;
    void** ecx20;
    void** v21;
    void** eax22;
    void** eax23;
    void** esi24;
    void** v25;
    void** v26;
    void** v27;
    void** v28;
    void** v29;
    void** v30;
    void** ecx31;
    void** eax32;

    ebp8 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    eax9 = g1000d050;
    v10 = reinterpret_cast<unsigned char>(eax9) ^ reinterpret_cast<uint32_t>(ebp8);
    ecx11 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp8) + 0xffffffec);
    fun_10001cd3(ecx11, ecx11, 5, "%04X", a1, ebx12, v13, v14, v15, v16, v17);
    v18 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp8) + 0xfffffff4);
    fun_10001cd3(ecx11, v18, 5, "%04X", a2, ecx11, 5, "%04X", a1, ebx12, v19);
    ecx20 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp8) + 0xfffffff4);
    eax22 = fun_10001140(ecx20, reinterpret_cast<uint32_t>(ebp8) + 0xffffffec, v18, 5, "%04X", a2, ecx11, 5, "%04X", a1, ebx12, v21);
    if (eax22 == 0xffffffff || !eax22) {
        CloseHandle(ecx20);
        eax23 = fun_10001cc4(v10 ^ reinterpret_cast<uint32_t>(ebp8), ebx12);
        return eax23;
    } else {
        fun_10005bc0(ecx20, reinterpret_cast<uint32_t>(ebp8) + 0xffffffa8, 0, 67, esi24, ebx12, v25, v26, v27, v28, v29, v30);
        fun_10001070();
        CloseHandle();
        ecx31 = reinterpret_cast<void**>(v10 ^ reinterpret_cast<uint32_t>(ebp8));
        eax32 = fun_10001cc4(ecx31, ebx12, ecx31, ebx12);
        return eax32;
    }
}

void** SetLEDBrightness(void** a1, void** a2, signed char a3, signed char a4, signed char a5) {
    void* ebp6;
    void** eax7;
    uint32_t v8;
    void** ecx9;
    void** ebx10;
    void** v11;
    void** v12;
    void** v13;
    void** v14;
    void** v15;
    void** v16;
    void** v17;
    void** ecx18;
    void** v19;
    void** eax20;
    void** eax21;
    void** esi22;
    void** v23;
    void** v24;
    void** v25;
    void** v26;
    void** v27;
    void** v28;
    void** ecx29;
    void** eax30;

    ebp6 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    eax7 = g1000d050;
    v8 = reinterpret_cast<unsigned char>(eax7) ^ reinterpret_cast<uint32_t>(ebp6);
    ecx9 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp6) + 0xffffffec);
    fun_10001cd3(ecx9, ecx9, 5, "%04X", a1, ebx10, v11, v12, v13, v14, v15);
    v16 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp6) + 0xfffffff4);
    fun_10001cd3(ecx9, v16, 5, "%04X", a2, ecx9, 5, "%04X", a1, ebx10, v17);
    ecx18 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp6) + 0xfffffff4);
    eax20 = fun_10001140(ecx18, reinterpret_cast<uint32_t>(ebp6) + 0xffffffec, v16, 5, "%04X", a2, ecx9, 5, "%04X", a1, ebx10, v19);
    if (eax20 == 0xffffffff || !eax20) {
        CloseHandle(ecx18);
        eax21 = fun_10001cc4(v8 ^ reinterpret_cast<uint32_t>(ebp6), ebx10);
        return eax21;
    } else {
        fun_10005bc0(ecx18, reinterpret_cast<uint32_t>(ebp6) + 0xffffffa8, 0, 67, esi22, ebx10, v23, v24, v25, v26, v27, v28);
        fun_10001070();
        CloseHandle();
        ecx29 = reinterpret_cast<void**>(v8 ^ reinterpret_cast<uint32_t>(ebp6));
        eax30 = fun_10001cc4(ecx29, ebx10, ecx29, ebx10);
        return eax30;
    }
}

void** SetLEDInputEffect(void** a1, void** a2, signed char a3, signed char a4, signed char a5) {
    void* ebp6;
    void** eax7;
    uint32_t v8;
    void** ecx9;
    void** ebx10;
    void** v11;
    void** v12;
    void** v13;
    void** v14;
    void** v15;
    void** v16;
    void** v17;
    void** ecx18;
    void** v19;
    void** eax20;
    void** eax21;
    void** esi22;
    void** v23;
    void** v24;
    void** v25;
    void** v26;
    void** v27;
    void** v28;
    void** ecx29;
    void** eax30;

    ebp6 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    eax7 = g1000d050;
    v8 = reinterpret_cast<unsigned char>(eax7) ^ reinterpret_cast<uint32_t>(ebp6);
    ecx9 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp6) + 0xffffffec);
    fun_10001cd3(ecx9, ecx9, 5, "%04X", a1, ebx10, v11, v12, v13, v14, v15);
    v16 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp6) + 0xfffffff4);
    fun_10001cd3(ecx9, v16, 5, "%04X", a2, ecx9, 5, "%04X", a1, ebx10, v17);
    ecx18 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp6) + 0xfffffff4);
    eax20 = fun_10001140(ecx18, reinterpret_cast<uint32_t>(ebp6) + 0xffffffec, v16, 5, "%04X", a2, ecx9, 5, "%04X", a1, ebx10, v19);
    if (eax20 == 0xffffffff || !eax20) {
        CloseHandle(ecx18);
        eax21 = fun_10001cc4(v8 ^ reinterpret_cast<uint32_t>(ebp6), ebx10);
        return eax21;
    } else {
        fun_10005bc0(ecx18, reinterpret_cast<uint32_t>(ebp6) + 0xffffffa8, 0, 67, esi22, ebx10, v23, v24, v25, v26, v27, v28);
        fun_10001070();
        CloseHandle();
        ecx29 = reinterpret_cast<void**>(v8 ^ reinterpret_cast<uint32_t>(ebp6));
        eax30 = fun_10001cc4(ecx29, ebx10, ecx29, ebx10);
        return eax30;
    }
}

void** SetLEDInputColor(void** a1, void** a2, signed char a3, signed char a4, signed char a5, signed char a6, signed char a7) {
    void* ebp8;
    void** eax9;
    uint32_t v10;
    void** ecx11;
    void** edi12;
    void** ebx13;
    void** v14;
    void** v15;
    void** v16;
    void** v17;
    void** v18;
    void** ecx19;
    void** eax20;
    void** eax21;
    void** esi22;
    void** v23;
    void** v24;
    void** v25;
    void** v26;
    void** v27;
    void** ecx28;
    void** eax29;

    ebp8 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    eax9 = g1000d050;
    v10 = reinterpret_cast<unsigned char>(eax9) ^ reinterpret_cast<uint32_t>(ebp8);
    ecx11 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp8) + 0xffffffec);
    fun_10001cd3(ecx11, ecx11, 5, "%04X", a1, edi12, ebx13, v14, v15, v16, v17);
    v18 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp8) + 0xfffffff4);
    fun_10001cd3(ecx11, v18, 5, "%04X", a2, ecx11, 5, "%04X", a1, edi12, ebx13);
    ecx19 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp8) + 0xfffffff4);
    eax20 = fun_10001140(ecx19, reinterpret_cast<uint32_t>(ebp8) + 0xffffffec, v18, 5, "%04X", a2, ecx11, 5, "%04X", a1, edi12, ebx13);
    if (eax20 == 0xffffffff || !eax20) {
        CloseHandle(ecx19);
        eax21 = fun_10001cc4(v10 ^ reinterpret_cast<uint32_t>(ebp8), ebx13);
        return eax21;
    } else {
        fun_10005bc0(ecx19, reinterpret_cast<uint32_t>(ebp8) + 0xffffffa8, 0, 67, esi22, edi12, ebx13, v23, v24, v25, v26, v27);
        fun_10001070();
        CloseHandle();
        ecx28 = reinterpret_cast<void**>(v10 ^ reinterpret_cast<uint32_t>(ebp8));
        eax29 = fun_10001cc4(ecx28, ebx13, ecx28, ebx13);
        return eax29;
    }
}

void** SetLEDInputBrightness(void** a1, void** a2, signed char a3, signed char a4) {
    void* ebp5;
    void** eax6;
    uint32_t v7;
    void** ecx8;
    void** ebx9;
    void** v10;
    void** v11;
    void** v12;
    void** v13;
    void** v14;
    void** v15;
    void** v16;
    void** ecx17;
    void** v18;
    void** eax19;
    void** eax20;
    void** esi21;
    void** v22;
    void** v23;
    void** v24;
    void** v25;
    void** v26;
    void** v27;
    void** ecx28;
    void** eax29;

    ebp5 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    eax6 = g1000d050;
    v7 = reinterpret_cast<unsigned char>(eax6) ^ reinterpret_cast<uint32_t>(ebp5);
    ecx8 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp5) + 0xffffffec);
    fun_10001cd3(ecx8, ecx8, 5, "%04X", a1, ebx9, v10, v11, v12, v13, v14);
    v15 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp5) + 0xfffffff4);
    fun_10001cd3(ecx8, v15, 5, "%04X", a2, ecx8, 5, "%04X", a1, ebx9, v16);
    ecx17 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp5) + 0xfffffff4);
    eax19 = fun_10001140(ecx17, reinterpret_cast<uint32_t>(ebp5) + 0xffffffec, v15, 5, "%04X", a2, ecx8, 5, "%04X", a1, ebx9, v18);
    if (eax19 == 0xffffffff || !eax19) {
        CloseHandle(ecx17);
        eax20 = fun_10001cc4(v7 ^ reinterpret_cast<uint32_t>(ebp5), ebx9);
        return eax20;
    } else {
        fun_10005bc0(ecx17, reinterpret_cast<uint32_t>(ebp5) + 0xffffffa8, 0, 67, esi21, ebx9, v22, v23, v24, v25, v26, v27);
        fun_10001070();
        CloseHandle();
        ecx28 = reinterpret_cast<void**>(v7 ^ reinterpret_cast<uint32_t>(ebp5));
        eax29 = fun_10001cc4(ecx28, ebx9, ecx28, ebx9);
        return eax29;
    }
}

void** SetDebounceInfo(void** a1, void** a2, signed char a3) {
    void* ebp4;
    void** eax5;
    uint32_t v6;
    void** ecx7;
    void** edi8;
    void** ebx9;
    void** v10;
    void** v11;
    void** v12;
    void** v13;
    void** v14;
    void** ecx15;
    void** eax16;
    void** eax17;
    void** esi18;
    void** v19;
    void** v20;
    void** v21;
    void** v22;
    void** v23;
    void** eax24;

    ebp4 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    eax5 = g1000d050;
    v6 = reinterpret_cast<unsigned char>(eax5) ^ reinterpret_cast<uint32_t>(ebp4);
    ecx7 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp4) + 0xffffffec);
    fun_10001cd3(ecx7, ecx7, 5, "%04X", a1, edi8, ebx9, v10, v11, v12, v13);
    v14 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp4) + 0xfffffff4);
    fun_10001cd3(ecx7, v14, 5, "%04X", a2, ecx7, 5, "%04X", a1, edi8, ebx9);
    ecx15 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp4) + 0xfffffff4);
    eax16 = fun_10001140(ecx15, reinterpret_cast<uint32_t>(ebp4) + 0xffffffec, v14, 5, "%04X", a2, ecx7, 5, "%04X", a1, edi8, ebx9);
    if (eax16 == 0xffffffff || !eax16) {
        CloseHandle(ecx15);
        eax17 = fun_10001cc4(v6 ^ reinterpret_cast<uint32_t>(ebp4), ebx9);
        return eax17;
    } else {
        fun_10005bc0(ecx15, reinterpret_cast<uint32_t>(ebp4) + 0xffffffa8, 0, 67, esi18, edi8, ebx9, v19, v20, v21, v22, v23);
        fun_10001070();
        CloseHandle(ecx15);
        eax24 = fun_10001cc4(v6 ^ reinterpret_cast<uint32_t>(ebp4), ebx9);
        return eax24;
    }
}

void** SetPollingRateInfo(void** a1, void** a2, signed char a3) {
    void* ebp4;
    void** eax5;
    uint32_t v6;
    void** ecx7;
    void** edi8;
    void** ebx9;
    void** v10;
    void** v11;
    void** v12;
    void** v13;
    void** v14;
    void** ecx15;
    void** eax16;
    void** eax17;
    void** esi18;
    void** v19;
    void** v20;
    void** v21;
    void** v22;
    void** v23;
    void** eax24;

    ebp4 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    eax5 = g1000d050;
    v6 = reinterpret_cast<unsigned char>(eax5) ^ reinterpret_cast<uint32_t>(ebp4);
    ecx7 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp4) + 0xffffffec);
    fun_10001cd3(ecx7, ecx7, 5, "%04X", a1, edi8, ebx9, v10, v11, v12, v13);
    v14 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp4) + 0xfffffff4);
    fun_10001cd3(ecx7, v14, 5, "%04X", a2, ecx7, 5, "%04X", a1, edi8, ebx9);
    ecx15 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp4) + 0xfffffff4);
    eax16 = fun_10001140(ecx15, reinterpret_cast<uint32_t>(ebp4) + 0xffffffec, v14, 5, "%04X", a2, ecx7, 5, "%04X", a1, edi8, ebx9);
    if (eax16 == 0xffffffff || !eax16) {
        CloseHandle(ecx15);
        eax17 = fun_10001cc4(v6 ^ reinterpret_cast<uint32_t>(ebp4), ebx9);
        return eax17;
    } else {
        fun_10005bc0(ecx15, reinterpret_cast<uint32_t>(ebp4) + 0xffffffa8, 0, 67, esi18, edi8, ebx9, v19, v20, v21, v22, v23);
        fun_10001070();
        CloseHandle(ecx15);
        eax24 = fun_10001cc4(v6 ^ reinterpret_cast<uint32_t>(ebp4), ebx9);
        return eax24;
    }
}

void** OpenDevice(void** a1, void** a2) {
    void*** ebp3;
    void** eax4;
    void** v5;
    void** ecx6;
    void** v7;
    void** v8;
    void** v9;
    void** v10;
    void** ebp11;
    void** v12;
    void** v13;
    void** v14;
    void** ecx15;
    void** v16;
    void** v17;
    void** eax18;
    void** eax19;
    void** eax20;

    ebp3 = reinterpret_cast<void***>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    eax4 = g1000d050;
    v5 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax4) ^ reinterpret_cast<uint32_t>(ebp3));
    ecx6 = reinterpret_cast<void**>(ebp3 + 0xfffffff4);
    fun_10001cd3(ecx6, ecx6, 5, "%04X", a1, v7, v8, v9, v10, v5, ebp11);
    v12 = reinterpret_cast<void**>(ebp3 + 0xffffffec);
    fun_10001cd3(ecx6, v12, 5, "%04X", a2, ecx6, 5, "%04X", a1, v13, v14);
    ecx15 = reinterpret_cast<void**>(ebp3 + 0xffffffec);
    eax18 = fun_10001140(ecx15, ebp3 + 0xfffffff4, v12, 5, "%04X", a2, ecx6, 5, "%04X", a1, v16, v17);
    if (eax18 == 0xffffffff || !eax18) {
        CloseHandle(ecx15, eax18);
        eax19 = fun_10001cc4(reinterpret_cast<unsigned char>(v5) ^ reinterpret_cast<uint32_t>(ebp3), eax18);
        return eax19;
    } else {
        CloseHandle(ecx15, eax18);
        eax20 = fun_10001cc4(reinterpret_cast<unsigned char>(v5) ^ reinterpret_cast<uint32_t>(ebp3), eax18);
        return eax20;
    }
}

void fun_100021b7() {
    goto 0x10002223;
}

void fun_10002324(void** a1, void** a2, void** a3) {
    void** ebp4;

    if (reinterpret_cast<int1_t>(a2 == 1)) {
        fun_100048cf();
    }
    fun_1000222e(a3, a1, ebp4, __return_address(), a1, a2, a3);
    return;
}

void** fun_10002301() {
    void** ecx1;
    int32_t ebp2;
    void** v3;
    void** eax4;

    ecx1 = *reinterpret_cast<void***>(*reinterpret_cast<void***>(*reinterpret_cast<void***>(ebp2 - 20)));
    v3 = *reinterpret_cast<void***>(ebp2 - 20);
    eax4 = fun_100048a9(ecx1, ecx1, v3, __return_address());
    return eax4;
}

void** fun_10002352(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13) {
    void** esi14;
    void** ebp15;

    *reinterpret_cast<void***>(ecx) = reinterpret_cast<void**>("R#");
    fun_10004a27(ecx, esi14, ebp15, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
    if (*reinterpret_cast<unsigned char*>(&a2) & 1) {
        fun_10001cb9(ecx, ecx, esi14, ebp15, __return_address());
    }
    return ecx;
}

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

int32_t fun_10004987(struct s134* ecx) {
    int32_t eax2;

    eax2 = ecx->f4;
    if (!eax2) {
        eax2 = reinterpret_cast<int32_t>("Unknown exception");
    }
    return eax2;
}

int32_t fun_100056bc(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
    void** eax8;
    void** esi9;
    void** eax10;
    void* edx11;
    int32_t ecx12;
    uint32_t edx13;
    int32_t* ecx14;

    eax8 = g1000fb20;
    if (eax8) {
        if (reinterpret_cast<signed char>(eax8) >= reinterpret_cast<signed char>(20)) {
            addr_100056db_3:
            eax10 = fun_10003b2d(ecx, eax8, 4, esi9, __return_address(), a2, a3, a4, a5, a6, a7);
            g1000eb04 = eax10;
            if (eax10 || (g1000fb20 = reinterpret_cast<void**>(20), eax10 = fun_10003b2d(4, 20, 4, esi9, __return_address(), a2, a3, a4, a5, a6, a7), g1000eb04 = eax10, !!eax10)) {
                edx11 = reinterpret_cast<void*>(0);
                ecx12 = 0x1000d990;
                while (*reinterpret_cast<int32_t*>(reinterpret_cast<int32_t>(edx11) + reinterpret_cast<unsigned char>(eax10)) = ecx12, ecx12 = ecx12 + 32, edx11 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(edx11) + 4), ecx12 < 0x1000dc10) {
                    eax10 = g1000eb04;
                }
                edx13 = 0;
                ecx14 = reinterpret_cast<int32_t*>(0x1000d9a0);
                do {
                    if (*reinterpret_cast<int32_t*>(((edx13 & 31) << 6) + reinterpret_cast<int32_t>(*reinterpret_cast<int32_t**>((reinterpret_cast<int32_t>(edx13) >> 5) * 4 + 0x1000fb40))) == -1 || (*reinterpret_cast<int32_t*>(((edx13 & 31) << 6) + reinterpret_cast<int32_t>(*reinterpret_cast<int32_t**>((reinterpret_cast<int32_t>(edx13) >> 5) * 4 + 0x1000fb40))) == 0xfe || !*reinterpret_cast<int32_t*>(((edx13 & 31) << 6) + reinterpret_cast<int32_t>(*reinterpret_cast<int32_t**>((reinterpret_cast<int32_t>(edx13) >> 5) * 4 + 0x1000fb40))))) {
                        *ecx14 = 0xfe;
                    }
                    ecx14 = ecx14 + 8;
                    ++edx13;
                } while (reinterpret_cast<int32_t>(ecx14) < 0x1000da00);
                return 0;
            } else {
                return 26;
            }
        } else {
            eax8 = reinterpret_cast<void**>(20);
        }
    } else {
        eax8 = reinterpret_cast<void**>(0x200);
    }
    g1000fb20 = eax8;
    goto addr_100056db_3;
}

void fun_10002a25() {
}

struct s135 {
    void* f0;
    void* f4;
    void* f8;
    void* f12;
};

int32_t g1000fb28;

int32_t fun_100045d0(void** a1, void** a2, void** a3) {
    void** v4;
    void** ebx5;
    void** ebx6;
    uint32_t v7;
    uint32_t esi8;
    struct s135* esi9;
    void** v10;
    void** edi11;
    void* eax12;
    signed char v13;
    int32_t v14;
    void** edi15;
    void** ecx16;
    void** ecx17;
    void** v18;
    void** v19;
    void*** eax20;
    int32_t ecx21;
    struct s56* eax22;
    void** eax23;
    int32_t eax24;
    int1_t sf25;
    void** ecx26;
    void** ecx27;
    int1_t zf28;
    uint32_t eax29;
    void** eax30;
    void** ecx31;
    void** ecx32;
    void** ecx33;

    v4 = ebx5;
    ebx6 = a2;
    v7 = esi8;
    esi9 = reinterpret_cast<struct s135*>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(ebx6 + 8)) ^ reinterpret_cast<unsigned char>(g1000d050));
    v10 = edi11;
    eax12 = esi9->f0;
    v13 = 0;
    v14 = 1;
    edi15 = ebx6 + 16;
    if (eax12 != -2) {
        ecx16 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(esi9->f4) + reinterpret_cast<unsigned char>(edi15) ^ *reinterpret_cast<uint32_t*>(reinterpret_cast<int32_t>(eax12) + reinterpret_cast<unsigned char>(edi15)));
        fun_10001cc4(ecx16, v10);
    }
    ecx17 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(esi9->f12) + reinterpret_cast<unsigned char>(edi15) ^ *reinterpret_cast<uint32_t*>(reinterpret_cast<int32_t>(esi9->f8) + reinterpret_cast<unsigned char>(edi15)));
    fun_10001cc4(ecx17, v10);
    if (reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a1 + 4)) & 0x66) {
        addr_1000473f_4:
        if (*reinterpret_cast<void***>(ebx6 + 12) == 0xfffffffe) {
            addr_1000469c_5:
            return v14;
        } else {
            fun_100074ab(ebx6, edi15, 0x1000d050);
        }
    } else {
        *reinterpret_cast<void**>(ebx6 + 0xfffffffc) = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4 - 24);
        ebx6 = *reinterpret_cast<void***>(ebx6 + 12);
        v18 = a1;
        v19 = a3;
        if (ebx6 == 0xfffffffe) 
            goto addr_1000469c_5;
        do {
            eax20 = reinterpret_cast<void***>(ebx6 + reinterpret_cast<unsigned char>(ebx6) * 2);
            ecx21 = *reinterpret_cast<int32_t*>(reinterpret_cast<uint32_t>(esi9) + reinterpret_cast<uint32_t>(eax20) * 4 + 20);
            eax22 = reinterpret_cast<struct s56*>(reinterpret_cast<uint32_t>(esi9) + reinterpret_cast<uint32_t>(eax20) * 4 + 16);
            eax23 = eax22->f0;
            if (ecx21) {
                eax24 = fun_10007462(ecx21);
                v13 = 1;
                sf25 = eax24 < 0;
                if (sf25) 
                    goto addr_100046a6_11;
                if (!reinterpret_cast<uint1_t>(reinterpret_cast<uint1_t>(sf25) | reinterpret_cast<uint1_t>(eax24 == 0))) 
                    goto addr_100046af_13;
                eax23 = eax23;
            }
            ebx6 = eax23;
        } while (!reinterpret_cast<int1_t>(eax23 == 0xfffffffe));
        goto addr_10004672_16;
    }
    addr_10004678_17:
    if (esi9->f0 != -2) {
        ecx26 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(esi9->f4) + reinterpret_cast<unsigned char>(edi15) ^ *reinterpret_cast<uint32_t*>(reinterpret_cast<int32_t>(esi9->f0) + reinterpret_cast<unsigned char>(edi15)));
        fun_10001cc4(ecx26, v10, ecx26, v10);
    }
    ecx27 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(esi9->f12) + reinterpret_cast<unsigned char>(edi15) ^ *reinterpret_cast<uint32_t*>(reinterpret_cast<int32_t>(esi9->f8) + reinterpret_cast<unsigned char>(edi15)));
    fun_10001cc4(ecx27, v10, ecx27, v10);
    goto addr_1000469c_5;
    addr_10004672_16:
    if (!v13) 
        goto addr_1000469c_5; else 
        goto addr_10004678_17;
    addr_100046a6_11:
    v14 = 0;
    goto addr_10004678_17;
    addr_100046af_13:
    if (reinterpret_cast<int1_t>(*reinterpret_cast<void***>(a1) == 0xe06d7363) && ((zf28 = g1000fb28 == 0, !zf28) && (eax29 = fun_100078f0(a1, 0x1000fb28), !!eax29))) {
        g1000fb28(a1, 1);
    }
    fun_10007492(a2);
    eax30 = a2;
    if (*reinterpret_cast<void***>(eax30 + 12) != ebx6) {
        fun_100074ab(eax30, edi15, 0x1000d050);
        eax30 = a2;
    }
    *reinterpret_cast<void***>(eax30 + 12) = eax23;
    if (esi9->f0 != -2) {
        ecx31 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(esi9->f4) + reinterpret_cast<unsigned char>(edi15) ^ *reinterpret_cast<uint32_t*>(reinterpret_cast<int32_t>(esi9->f0) + reinterpret_cast<unsigned char>(edi15)));
        fun_10001cc4(ecx31, v10, ecx31, v10);
    }
    ecx32 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(esi9->f12) + reinterpret_cast<unsigned char>(edi15) ^ *reinterpret_cast<uint32_t*>(reinterpret_cast<int32_t>(esi9->f8) + reinterpret_cast<unsigned char>(edi15)));
    fun_10001cc4(ecx32, v10, ecx32, v10);
    ecx33 = eax22->f8;
    fun_10007479(ecx33, v10, v7, v4, v18, v19, eax22);
    goto addr_1000473f_4;
}

uint32_t fun_10003aa3() {
    int32_t eax1;
    int32_t eax2;
    uint32_t eax3;
    int32_t eax4;
    uint1_t cf5;

    return (eax1 - (eax2 + reinterpret_cast<uint1_t>(eax3 < eax4 + cf5)) << 1) + 1;
}

void fun_10003516() {
    TlsAlloc();
    return;
}

void fun_10004b34(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7) {
    void** esi8;
    void** eax9;
    void** eax10;

    eax9 = fun_10003b2d(ecx, 32, 4, esi8, __return_address(), a2, a3, a4, a5, a6, a7);
    eax10 = reinterpret_cast<void**>(EncodePointer(4));
    g1000fc48 = eax10;
    g1000fc44 = eax10;
    if (eax9) {
        *reinterpret_cast<void***>(eax9) = reinterpret_cast<void**>(0);
        goto esi8;
    } else {
        goto esi8;
    }
}

void fun_1000560c() {
}

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

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

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

struct s136 {
    signed char[112] pad112;
    uint32_t f112;
};

void** fun_10005ccf(void** a1, void** a2, void** a3, void*** a4) {
    void* ebp5;
    void** eax6;
    uint32_t v7;
    void** v8;
    void** ebx9;
    void** ebx10;
    void** v11;
    void** esi12;
    void** v13;
    void** edi14;
    void*** edi15;
    void** ecx16;
    void** v17;
    void*** v18;
    void** v19;
    void** v20;
    void** v21;
    void** v22;
    void** v23;
    void** v24;
    void** v25;
    void** v26;
    void** v27;
    void** v28;
    void** v29;
    void** v30;
    void** v31;
    void** v32;
    void** v33;
    void** v34;
    void** v35;
    void** v36;
    void** v37;
    void** v38;
    void** eax39;
    void** v40;
    void** v41;
    void** v42;
    void** v43;
    void** v44;
    void** eax45;
    void** edx46;
    void** eax47;
    void** v48;
    void** v49;
    void** v50;
    void** v51;
    void** v52;
    void** ebx53;
    void** v54;
    uint32_t eax55;
    uint32_t eax56;
    uint32_t eax57;
    void** eax58;
    uint32_t eax59;
    void** v60;
    void** v61;
    void** al62;
    void** v63;
    int32_t eax64;
    int32_t eax65;
    uint32_t eax66;
    uint32_t eax67;
    void*** edi68;
    void** edi69;
    void*** edi70;
    void** edi71;
    void** al72;
    int32_t eax73;
    int32_t eax74;
    int32_t eax75;
    void** v76;
    int32_t eax77;
    int32_t eax78;
    void** eax79;
    void** eax80;
    void** v81;
    void** v82;
    void** eax83;
    uint32_t eax84;
    void** ebx85;
    void** v86;
    void** esi87;
    void** v88;
    void** v89;
    void** v90;
    void** eax91;
    int32_t eax92;
    void*** edi93;
    void** edi94;
    void** eax95;
    void** eax96;
    void** eax97;
    void** eax98;
    void*** edi99;
    void** eax100;
    uint1_t less101;
    uint1_t cf102;
    void** edi103;
    void** ebx104;
    uint32_t eax105;
    void* esi106;
    void** eax107;
    void** eax108;
    void** eax109;
    void** esi110;
    void** v111;
    void** v112;
    void** v113;
    void** v114;
    void** v115;
    void** v116;
    void** v117;
    void** ecx118;
    void** eax119;
    void** edi120;
    void** ebx121;
    void** edi122;
    void** esi123;
    uint32_t eax124;
    void** eax125;
    void** v126;
    void** v127;
    void** edi128;
    void** esi129;
    int32_t eax130;
    int32_t esi131;
    void*** edi132;
    int32_t v133;
    void* v134;
    int32_t v135;
    int32_t eax136;
    uint32_t edi137;
    int32_t eax138;
    int32_t eax139;
    void*** edi140;
    uint32_t v141;
    void** eax142;
    int32_t eax143;
    int32_t eax144;
    signed char v145;
    struct s136* v146;
    void** v147;
    void** v148;
    void** eax149;
    signed char v150;
    void** v151;
    void** ecx152;
    void** eax153;

    ebp5 = reinterpret_cast<void*>(reinterpret_cast<int32_t>(__zero_stack_offset()) - 4);
    eax6 = g1000d050;
    v7 = reinterpret_cast<unsigned char>(eax6) ^ reinterpret_cast<uint32_t>(ebp5);
    v8 = ebx9;
    ebx10 = a2;
    v11 = esi12;
    v13 = edi14;
    edi15 = a4;
    ecx16 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp5) + 0xfffffdac);
    v17 = a1;
    v18 = edi15;
    v19 = reinterpret_cast<void**>(0);
    v20 = reinterpret_cast<void**>(0);
    v21 = reinterpret_cast<void**>(0);
    v22 = reinterpret_cast<void**>(0);
    v23 = reinterpret_cast<void**>(0);
    v24 = reinterpret_cast<void**>(0);
    v25 = reinterpret_cast<void**>(0);
    fun_10001d91(ecx16, a3, v13, v11, v8, v26, v27, v28, v29, v30, v31);
    eax39 = fun_10002896(ecx16, v13, v11, v8, v32, v33, v34, v35, v36, v37, v38);
    v40 = eax39;
    if (!a1) 
        goto addr_10005d45_2;
    if (!(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(a1 + 12)) & 64)) {
        eax45 = fun_1000586b(ecx16, a1, v13, v11, v8, v41, v42, v43, v44);
        edx46 = reinterpret_cast<void**>(0x1000d950);
        if (eax45 == 0xffffffff || eax45 == 0xfffffffe) {
            ecx16 = reinterpret_cast<void**>(0x1000d950);
        } else {
            ecx16 = reinterpret_cast<void**>(((reinterpret_cast<unsigned char>(eax45) & 31) << 6) + reinterpret_cast<uint32_t>(*reinterpret_cast<void****>((reinterpret_cast<signed char>(eax45) >> 5) * 4 + 0x1000fb40)));
        }
        if (reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(ecx16 + 36)) & 0x7f) 
            goto addr_10005d45_2;
        if (eax45 == 0xffffffff || eax45 == 0xfffffffe) {
            eax47 = reinterpret_cast<void**>(0x1000d950);
        } else {
            ecx16 = reinterpret_cast<void**>(reinterpret_cast<signed char>(eax45) >> 5);
            eax47 = reinterpret_cast<void**>(((reinterpret_cast<unsigned char>(eax45) & 31) << 6) + reinterpret_cast<uint32_t>(*reinterpret_cast<void****>(reinterpret_cast<unsigned char>(ecx16) * 4 + 0x1000fb40)));
        }
        if (reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(eax47 + 36)) & 0x80) 
            goto addr_10005d45_2;
    }
    if (!ebx10) 
        goto addr_10005d45_2;
    edx46 = *reinterpret_cast<void***>(ebx10);
    v48 = reinterpret_cast<void**>(0);
    v49 = reinterpret_cast<void**>(0);
    v50 = reinterpret_cast<void**>(0);
    v51 = reinterpret_cast<void**>(0);
    v52 = edx46;
    if (!edx46) 
        goto addr_100068b8_14;
    while (ebx53 = ebx10 + 1, v54 = ebx53, reinterpret_cast<signed char>(v48) >= reinterpret_cast<signed char>(0)) {
        eax55 = reinterpret_cast<uint32_t>(edx46 + 0xffffffe0);
        if (*reinterpret_cast<unsigned char*>(&eax55) > 88) {
            eax56 = 0;
        } else {
            eax56 = static_cast<uint32_t>(*reinterpret_cast<unsigned char*>(edx46 + 0x1000a6b8)) & 15;
        }
        ecx16 = v50;
        eax57 = *reinterpret_cast<unsigned char*>(reinterpret_cast<uint32_t>(ecx16 + eax56 * 9) + 0x1000a6d8);
        eax58 = reinterpret_cast<void**>(eax57 >> 4);
        v50 = eax58;
        if (eax58 == 8) 
            goto addr_10005d45_2;
        ecx16 = reinterpret_cast<void**>(7);
        switch (eax58) {
            addr_1000606b_22:
        case 0:
            v25 = reinterpret_cast<void**>(0);
            eax59 = fun_10005acd(7, static_cast<uint32_t>(reinterpret_cast<unsigned char>(edx46)), reinterpret_cast<uint32_t>(ebp5) + 0xfffffdac, v13);
            if (!eax59) 
                goto addr_100060b0_23;
            ecx16 = v17;
            fun_10005c3a(ecx16, v13, v11, v8, v60, v61);
            al62 = *reinterpret_cast<void***>(ebx53);
            v54 = ebx53 + 1;
            if (!al62) 
                goto addr_10005d45_2;
            addr_100060b0_23:
            ecx16 = v17;
            fun_10005c3a(ecx16, v13, v11, v8, v60, v61);
            goto addr_10006881_25;
        case 1:
            v22 = reinterpret_cast<void**>(0xffffffff);
            v63 = reinterpret_cast<void**>(0);
            v24 = reinterpret_cast<void**>(0);
            v21 = reinterpret_cast<void**>(0);
            v23 = reinterpret_cast<void**>(0);
            v20 = reinterpret_cast<void**>(0);
            v25 = reinterpret_cast<void**>(0);
            goto addr_10006881_25;
        case 2:
            eax64 = reinterpret_cast<int32_t>(edx46 - 32);
            if (!eax64) {
                v20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) | 2);
                goto addr_10006881_25;
            } else {
                eax65 = eax64 - 3;
                if (!eax65) {
                    v20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) | 0x80);
                    goto addr_10006881_25;
                } else {
                    eax66 = eax65 - reinterpret_cast<unsigned char>(8);
                    if (!eax66) {
                        v20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) | 1);
                        goto addr_10006881_25;
                    } else {
                        eax67 = eax66 - 1 - 1;
                        if (!eax67) {
                            v20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) | 4);
                            goto addr_10006881_25;
                        } else {
                            if (!(eax67 - 3)) {
                                v20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) | reinterpret_cast<unsigned char>(8));
                                goto addr_10006881_25;
                            }
                        }
                    }
                }
            }
        case 3:
            if (!reinterpret_cast<int1_t>(edx46 == 42)) {
                ecx16 = reinterpret_cast<void**>(static_cast<int32_t>(reinterpret_cast<signed char>(edx46)));
                v21 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ecx16 + reinterpret_cast<unsigned char>(v21) * 10) + 0xffffffd0);
                goto addr_10006881_25;
            } else {
                edi68 = edi15 + 4;
                v18 = edi68;
                edi69 = *(edi68 - 4);
                v21 = edi69;
                if (reinterpret_cast<signed char>(edi69) < reinterpret_cast<signed char>(0)) {
                    v20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) | 4);
                    v21 = reinterpret_cast<void**>(-reinterpret_cast<unsigned char>(v21));
                    goto addr_10006881_25;
                }
            }
        case 4:
            v22 = reinterpret_cast<void**>(0);
            goto addr_10006881_25;
        case 5:
            if (!reinterpret_cast<int1_t>(edx46 == 42)) {
                ecx16 = reinterpret_cast<void**>(static_cast<int32_t>(reinterpret_cast<signed char>(edx46)));
                v22 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ecx16 + reinterpret_cast<unsigned char>(v22) * 10) + 0xffffffd0);
                goto addr_10006881_25;
            } else {
                edi70 = edi15 + 4;
                v18 = edi70;
                edi71 = *(edi70 - 4);
                v22 = edi71;
                if (reinterpret_cast<signed char>(edi71) < reinterpret_cast<signed char>(0)) {
                    v22 = reinterpret_cast<void**>(0xffffffff);
                    goto addr_10006881_25;
                }
            }
        case 6:
            if (edx46 != 73) {
                if (edx46 == 0x68) {
                    v20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) | 32);
                    goto addr_10006881_25;
                } else {
                    if (edx46 == 0x6c) {
                        if (!reinterpret_cast<int1_t>(*reinterpret_cast<void***>(ebx53) == 0x6c)) {
                            v20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) | 16);
                            goto addr_10006881_25;
                        } else {
                            v20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) | 0x1000);
                            v54 = ebx53 + 1;
                            goto addr_10006881_25;
                        }
                    } else {
                        if (reinterpret_cast<int1_t>(edx46 == 0x77)) {
                            v20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) | 0x800);
                            goto addr_10006881_25;
                        }
                    }
                }
            }
            if (reinterpret_cast<int1_t>(*reinterpret_cast<void***>(ebx53) == 54) && reinterpret_cast<int1_t>(*reinterpret_cast<void***>(ebx53 + 1) == 52)) {
                v20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) | 0x8000);
                v54 = ebx53 + 2;
                goto addr_10006881_25;
            }
            if (reinterpret_cast<int1_t>(*reinterpret_cast<void***>(ebx53) == 51) && reinterpret_cast<int1_t>(*reinterpret_cast<void***>(ebx53 + 1) == 50)) {
                v20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) & 0xffff7fff);
                v54 = ebx53 + 2;
                goto addr_10006881_25;
            }
            if (*reinterpret_cast<void***>(ebx53) == 100 || (*reinterpret_cast<void***>(ebx53) == 0x69 || (*reinterpret_cast<void***>(ebx53) == 0x6f || (*reinterpret_cast<void***>(ebx53) == 0x75 || (*reinterpret_cast<void***>(ebx53) == 0x78 || *reinterpret_cast<void***>(ebx53) == 88))))) {
                addr_10006881_25:
                ebx10 = v54;
                al72 = *reinterpret_cast<void***>(ebx10);
                v52 = al72;
                if (!al72) 
                    goto addr_100068a2_60;
            } else {
                v50 = reinterpret_cast<void**>(0);
                goto addr_1000606b_22;
            }
            edi15 = v18;
            edx46 = al72;
            break;
        case 7:
            eax73 = reinterpret_cast<signed char>(edx46);
            if (eax73 > 100) {
                if (eax73 > 0x70) {
                    eax74 = eax73 - 0x73;
                    if (!eax74) {
                        addr_10006145_66:
                        ecx16 = v22;
                        if (reinterpret_cast<int1_t>(ecx16 == 0xffffffff)) {
                            ecx16 = reinterpret_cast<void**>(0x7fffffff);
                        }
                    } else {
                        eax75 = eax74 - 1 - 1;
                        if (!eax75) {
                            addr_10006334_69:
                            v76 = reinterpret_cast<void**>(10);
                            goto addr_1000633e_70;
                        } else {
                            if (eax75 - 3) 
                                goto addr_100066a0_72;
                            edi15 = v18;
                            v19 = reinterpret_cast<void**>(39);
                            goto addr_100064f2_74;
                        }
                    }
                } else {
                    if (eax73 == 0x70) {
                        v22 = reinterpret_cast<void**>(8);
                        goto addr_100064c0_77;
                    } else {
                        if (eax73 < 0x65) 
                            goto addr_100066a0_72;
                        if (eax73 <= 0x67) 
                            goto addr_1000635d_80; else 
                            goto addr_100062aa_81;
                    }
                }
            } else {
                if (eax73 == 100) {
                    addr_1000632d_83:
                    v20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) | 64);
                    goto addr_10006334_69;
                } else {
                    if (eax73 > 83) {
                        eax77 = eax73 - 88;
                        if (!eax77) {
                            addr_100064c0_77:
                            v19 = reinterpret_cast<void**>(7);
                            goto addr_100064f2_74;
                        } else {
                            eax78 = eax77 - 1 - 1;
                            if (!eax78) {
                                eax79 = *edi15;
                                v18 = edi15 + 4;
                                if (!eax79 || (ecx16 = *reinterpret_cast<void***>(eax79 + 4), ecx16 == 0)) {
                                    eax80 = image_base_;
                                    v81 = eax80;
                                    v82 = eax80;
                                    goto addr_1000627e_89;
                                } else {
                                    eax83 = reinterpret_cast<void**>(static_cast<int32_t>(reinterpret_cast<int16_t>(*reinterpret_cast<void***>(eax79))));
                                    v81 = ecx16;
                                    if (!(reinterpret_cast<unsigned char>(v20) & 0x800)) {
                                        v25 = reinterpret_cast<void**>(0);
                                        goto addr_1000669a_92;
                                    } else {
                                        __asm__("cdq ");
                                        eax83 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(reinterpret_cast<unsigned char>(eax83) - reinterpret_cast<unsigned char>(edx46)) >> 1);
                                        v25 = reinterpret_cast<void**>(1);
                                        goto addr_1000669a_92;
                                    }
                                }
                            } else {
                                eax84 = eax78 - reinterpret_cast<unsigned char>(7);
                                if (!eax84) {
                                    addr_10006363_95:
                                    v20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) | 64);
                                    ebx85 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp5) + 0xfffffdf4);
                                    v81 = ebx85;
                                    v86 = reinterpret_cast<void**>(0x200);
                                    if (reinterpret_cast<signed char>(v22) >= reinterpret_cast<signed char>(0)) {
                                        if (v22) {
                                            if (reinterpret_cast<signed char>(v22) > reinterpret_cast<signed char>(0x200)) {
                                                v22 = reinterpret_cast<void**>(0x200);
                                            }
                                            if (reinterpret_cast<signed char>(v22) > reinterpret_cast<signed char>(0xa3)) {
                                                esi87 = v22 + 0x15d;
                                                eax91 = fun_10003ae8(7, esi87, v13, v11, v8, v60, v61, v88, v63, v89, v90, 0x200, v40, v51, v24);
                                                edx46 = v52;
                                                ecx16 = esi87;
                                                v51 = eax91;
                                                if (!eax91) {
                                                    v22 = reinterpret_cast<void**>(0xa3);
                                                    goto addr_10006400_102;
                                                } else {
                                                    v81 = eax91;
                                                    v86 = esi87;
                                                    ebx85 = eax91;
                                                    goto addr_10006400_102;
                                                }
                                            }
                                        } else {
                                            if (reinterpret_cast<int1_t>(edx46 == 0x67)) {
                                                v22 = reinterpret_cast<void**>(1);
                                                goto addr_10006400_102;
                                            }
                                        }
                                    } else {
                                        v22 = reinterpret_cast<void**>(6);
                                        goto addr_10006400_102;
                                    }
                                } else {
                                    if (eax84 - 1 - 1) 
                                        goto addr_100066a0_72;
                                    edi15 = v18;
                                    goto addr_100061be_109;
                                }
                            }
                        }
                    } else {
                        if (eax73 == 83) {
                            if (!(reinterpret_cast<unsigned char>(v20) & 0x830)) {
                                v20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) | 0x800);
                                goto addr_10006145_66;
                            }
                        }
                        eax92 = eax73 - 65;
                        if (!eax92) 
                            goto addr_100060f8_114; else 
                            goto addr_100060e8_115;
                    }
                }
            }
            edi93 = edi15 + 4;
            v18 = edi93;
            edi94 = *(edi93 - 4);
            v81 = edi94;
            if (!(reinterpret_cast<unsigned char>(v20) & 0x810)) {
                if (!edi94) {
                    eax95 = image_base_;
                    v81 = eax95;
                }
                eax96 = v81;
                while (ecx16 && (--ecx16, !!*reinterpret_cast<void***>(eax96))) {
                    ++eax96;
                }
                eax83 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(eax96) - reinterpret_cast<unsigned char>(v81));
            } else {
                if (!edi94) {
                    eax97 = image_base_;
                    v81 = eax97;
                }
                eax98 = v81;
                v25 = reinterpret_cast<void**>(1);
                while (ecx16 && (--ecx16, !!*reinterpret_cast<void***>(eax98))) {
                    eax98 = eax98 + 2;
                }
                eax83 = reinterpret_cast<void**>(reinterpret_cast<int32_t>(reinterpret_cast<unsigned char>(eax98) - reinterpret_cast<unsigned char>(v81)) >> 1);
            }
            addr_1000669a_92:
            v49 = eax83;
            goto addr_100066a0_72;
            addr_1000633e_70:
            ecx16 = v20;
            if (reinterpret_cast<unsigned char>(ecx16) & 0x8000 || reinterpret_cast<unsigned char>(ecx16) & 0x1000) {
                edi99 = reinterpret_cast<void***>(reinterpret_cast<uint32_t>(edi15) + reinterpret_cast<unsigned char>(8));
                eax100 = *(edi99 - 8);
                edx46 = *(edi99 - 4);
            } else {
                edi99 = edi15 + 4;
                if (!(*reinterpret_cast<unsigned char*>(&ecx16) & 32)) {
                    eax100 = *(edi99 - 4);
                    if (!(*reinterpret_cast<unsigned char*>(&ecx16) & 64)) {
                        edx46 = reinterpret_cast<void**>(0);
                    } else {
                        __asm__("cdq ");
                    }
                } else {
                    v18 = edi99;
                    if (!(*reinterpret_cast<unsigned char*>(&ecx16) & 64)) {
                        eax100 = reinterpret_cast<void**>(static_cast<uint32_t>(reinterpret_cast<uint16_t>(*(edi99 - 4))));
                    } else {
                        eax100 = reinterpret_cast<void**>(static_cast<int32_t>(reinterpret_cast<int16_t>(*(edi99 - 4))));
                    }
                    __asm__("cdq ");
                    goto addr_1000656c_138;
                }
            }
            v18 = edi99;
            addr_1000656c_138:
            if (*reinterpret_cast<unsigned char*>(&ecx16) & 64 && ((less101 = reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(edx46) < reinterpret_cast<signed char>(0)), reinterpret_cast<uint1_t>(less101 | reinterpret_cast<uint1_t>(edx46 == 0))) && (less101 || !1))) {
                cf102 = reinterpret_cast<uint1_t>(!!eax100);
                eax100 = reinterpret_cast<void**>(-reinterpret_cast<unsigned char>(eax100));
                edx46 = reinterpret_cast<void**>(-(reinterpret_cast<unsigned char>(edx46) + cf102));
                v20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) | 0x100);
            }
            edi103 = edx46;
            ebx104 = eax100;
            if (!(reinterpret_cast<unsigned char>(v20) & 0x9000)) {
                edi103 = reinterpret_cast<void**>(0);
            }
            if (reinterpret_cast<signed char>(v22) >= reinterpret_cast<signed char>(0)) {
                v20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) & 0xfffffff7);
                if (reinterpret_cast<signed char>(v22) > reinterpret_cast<signed char>(0x200)) {
                    v22 = reinterpret_cast<void**>(0x200);
                }
            } else {
                v22 = reinterpret_cast<void**>(1);
            }
            eax105 = reinterpret_cast<unsigned char>(ebx104) | reinterpret_cast<unsigned char>(edi103);
            if (!eax105) {
                v23 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v23) & eax105);
            }
            esi106 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ebp5) + 0xfffffff3);
            while ((eax107 = v22, --v22, !reinterpret_cast<uint1_t>(reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(eax107) < reinterpret_cast<signed char>(0)) | reinterpret_cast<uint1_t>(eax107 == 0))) || reinterpret_cast<unsigned char>(ebx104) | reinterpret_cast<unsigned char>(edi103)) {
                __asm__("cdq ");
                eax108 = fun_10005b20(ebx104, edi103, v76, edx46);
                ecx16 = ecx16 + 48;
                v86 = ebx104;
                ebx104 = eax108;
                edi103 = edx46;
                if (reinterpret_cast<signed char>(ecx16) > reinterpret_cast<signed char>(57)) {
                    ecx16 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(ecx16) + reinterpret_cast<unsigned char>(v19));
                }
                esi106 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(esi106) - 1);
            }
            eax109 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp5) + 0xfffffff3 - reinterpret_cast<uint32_t>(esi106));
            esi110 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(esi106) + 1);
            v49 = eax109;
            v81 = esi110;
            if (!(reinterpret_cast<unsigned char>(v20) & 0x200) || eax109 && (ecx16 = esi110, v111 == 48)) {
                addr_100066a0_72:
                if (v24) {
                    addr_10006865_155:
                    if (v51) {
                        v112 = v51;
                        fun_10002416(ecx16, v112, v13, v11, v8, v60, v61, v113, v63, v89, v114, v86, v40, v51, v24, v19, v115, v116, v117);
                        v51 = reinterpret_cast<void**>(0);
                        ecx16 = v112;
                        goto addr_10006881_25;
                    }
                } else {
                    ecx118 = v20;
                    if (!(*reinterpret_cast<unsigned char*>(&ecx118) & 64)) 
                        goto addr_100066ed_158;
                    if (reinterpret_cast<unsigned char>(ecx118) & 0x100) 
                        goto addr_100066c0_160;
                }
            } else {
                --v81;
                ecx16 = v81;
                eax83 = eax109 + 1;
                goto addr_1000669a_92;
            }
            if (!(*reinterpret_cast<unsigned char*>(&ecx118) & 1)) {
                if (!(*reinterpret_cast<unsigned char*>(&ecx118) & 2)) {
                    addr_100066ed_158:
                    eax119 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v21) - reinterpret_cast<unsigned char>(v49) - reinterpret_cast<unsigned char>(v23));
                    v86 = eax119;
                    if (!(*reinterpret_cast<unsigned char*>(&ecx118) & 12)) {
                        edi120 = eax119;
                        do {
                            if (reinterpret_cast<uint1_t>(reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(edi120) < reinterpret_cast<signed char>(0)) | reinterpret_cast<uint1_t>(edi120 == 0))) 
                                break;
                            ecx118 = v17;
                            --edi120;
                            fun_10005c3a(ecx118, v13, v11, v8, v60, v61);
                        } while (v48 != 0xffffffff);
                    }
                } else {
                    goto addr_100066e3_168;
                }
            } else {
                goto addr_100066e3_168;
            }
            ebx121 = v17;
            fun_10005c6d(ecx118);
            ecx16 = v23;
            if (*reinterpret_cast<unsigned char*>(&v20) & 8 && !(*reinterpret_cast<unsigned char*>(&v20) & 4)) {
                edi122 = v86;
                do {
                    if (reinterpret_cast<uint1_t>(reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(edi122) < reinterpret_cast<signed char>(0)) | reinterpret_cast<uint1_t>(edi122 == 0))) 
                        break;
                    ecx16 = ebx121;
                    --edi122;
                    fun_10005c3a(ecx16, v13, v11, v8, v60, v61);
                } while (v48 != 0xffffffff);
            }
            if (!v25 || reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(v49) < reinterpret_cast<signed char>(0)) | reinterpret_cast<uint1_t>(v49 == 0)) {
                fun_10005c6d(ecx16);
                ecx16 = v49;
            } else {
                esi123 = v81;
                v89 = v49;
                do {
                    eax124 = reinterpret_cast<uint16_t>(*reinterpret_cast<void***>(esi123));
                    --v89;
                    esi123 = esi123 + 2;
                    eax125 = fun_10005ab0(ecx16, reinterpret_cast<uint32_t>(ebp5) + 0xfffffd88, reinterpret_cast<uint32_t>(ebp5) + 0xfffffff4, 6, eax124);
                    if (eax125) 
                        goto addr_10006807_178;
                    if (v126 == eax125) 
                        goto addr_10006807_178;
                    fun_10005c6d(ecx16);
                    ecx16 = v127;
                } while (v89);
                goto addr_10006805_181;
            }
            addr_1000682a_182:
            if (reinterpret_cast<signed char>(v48) >= reinterpret_cast<signed char>(0) && *reinterpret_cast<unsigned char*>(&v20) & 4) {
                edi128 = v86;
                do {
                    if (reinterpret_cast<uint1_t>(reinterpret_cast<uint1_t>(reinterpret_cast<signed char>(edi128) < reinterpret_cast<signed char>(0)) | reinterpret_cast<uint1_t>(edi128 == 0))) 
                        goto addr_10006865_155;
                    ecx16 = v17;
                    --edi128;
                    fun_10005c3a(ecx16, v13, v11, v8, v60, v61);
                } while (v48 != 0xffffffff);
                goto addr_10006865_155;
            }
            addr_10006807_178:
            v48 = reinterpret_cast<void**>(0xffffffff);
            goto addr_1000682a_182;
            addr_10006805_181:
            goto addr_1000682a_182;
            addr_100066e3_168:
            v23 = reinterpret_cast<void**>(1);
            goto addr_100066ed_158;
            addr_100066c0_160:
            goto addr_100066e3_168;
            addr_100064f2_74:
            v76 = reinterpret_cast<void**>(16);
            if (*reinterpret_cast<unsigned char*>(&v20) & 0x80) {
                v23 = reinterpret_cast<void**>(2);
                goto addr_1000633e_70;
            }
            addr_1000635d_80:
            edi15 = v18;
            goto addr_10006363_95;
            addr_100062aa_81:
            if (eax73 == 0x69) {
                edi15 = v18;
                goto addr_1000632d_83;
            } else {
                if (eax73 == 0x6e) {
                    v18 = v18 + 4;
                    esi129 = *(v18 - 4);
                    eax130 = fun_100058b4();
                    if (!eax130) 
                        goto addr_10005d45_2;
                    if (*reinterpret_cast<unsigned char*>(&v20) & 32) 
                        goto addr_10006304_191;
                } else {
                    if (eax73 != 0x6f) 
                        goto addr_100066a0_72;
                    edi15 = v18;
                    v76 = reinterpret_cast<void**>(8);
                    if (*reinterpret_cast<unsigned char*>(&v20) & 0x80) {
                        v20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) | 0x200);
                        goto addr_1000633e_70;
                    }
                }
            }
            *reinterpret_cast<void***>(esi129) = v48;
            addr_10006318_196:
            v24 = reinterpret_cast<void**>(1);
            goto addr_10006865_155;
            addr_10006304_191:
            *reinterpret_cast<void***>(esi129) = v48;
            goto addr_10006318_196;
            addr_1000627e_89:
            eax83 = fun_100058d0(v82, v13, v11, v8, v60, v61, v82, v13, v11, v8, v60, v61);
            ecx16 = v82;
            goto addr_1000669a_92;
            addr_10006400_102:
            esi131 = DecodePointer;
            edi132 = edi15 + 8;
            v60 = *edi15;
            v61 = *(edi132 - 4);
            v82 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp5) + 0xfffffdac);
            v18 = edi132;
            v133 = reinterpret_cast<signed char>(edx46);
            v134 = reinterpret_cast<void*>(reinterpret_cast<uint32_t>(ebp5) + 0xfffffd80);
            v135 = image_base_;
            eax136 = reinterpret_cast<int32_t>(esi131(ecx16, v135, v134, ebx85, v86, v133, v22, v63));
            eax136(ecx16, v135, v134, ebx85, v86, v133, v22, v63);
            edi137 = reinterpret_cast<unsigned char>(v20) & 0x80;
            if (edi137 && !v22) {
                eax138 = reinterpret_cast<int32_t>(esi131(ecx16));
                eax138(ecx16);
                ecx16 = ebx85;
            }
            if (reinterpret_cast<int1_t>(v52 == 0x67) && !edi137) {
                eax139 = reinterpret_cast<int32_t>(esi131(ecx16));
                eax139(ecx16);
            }
            if (reinterpret_cast<int1_t>(*reinterpret_cast<void***>(ebx85) == 45)) {
                v20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) | 0x100);
                ++ebx85;
                v81 = ebx85;
            }
            goto addr_1000627e_89;
            addr_100061be_109:
            edi140 = edi15 + 4;
            v18 = edi140;
            if (!(reinterpret_cast<unsigned char>(v20) & 0x810)) {
                v49 = reinterpret_cast<void**>(1);
            } else {
                v141 = reinterpret_cast<uint16_t>(*(edi140 - 4));
                eax142 = fun_10005ab0(7, reinterpret_cast<uint32_t>(ebp5) + 0xfffffdd8, reinterpret_cast<uint32_t>(ebp5) + 0xfffffdf4, 0x200, v141);
                if (eax142) {
                    v24 = reinterpret_cast<void**>(1);
                }
            }
            v81 = reinterpret_cast<void**>(reinterpret_cast<uint32_t>(ebp5) + 0xfffffdf4);
            goto addr_100066a0_72;
            addr_100060f8_114:
            edx46 = edx46 + 32;
            v63 = reinterpret_cast<void**>(1);
            v52 = edx46;
            goto addr_10006363_95;
            addr_100060e8_115:
            eax143 = eax92 - 1 - 1;
            if (!eax143) {
                if (!(reinterpret_cast<unsigned char>(v20) & 0x830)) {
                    v20 = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(v20) | 0x800);
                    goto addr_100061be_109;
                }
            } else {
                eax144 = eax143 - 1 - 1;
                if (!eax144) 
                    goto addr_100060f8_114;
                if (eax144 - 1 - 1) 
                    goto addr_100066a0_72; else 
                    goto addr_100060f8_114;
            }
        }
    }
    addr_100068a2_60:
    if (!v50 || reinterpret_cast<int1_t>(v50 == 7)) {
        addr_100068b8_14:
        if (v145) {
            v146->f112 = v146->f112 & 0xfffffffd;
        }
    } else {
        addr_10005d45_2:
        eax149 = fun_10002896(ecx16, v13, v11, v8, v60, v61, v147, v63, v89, v148, v86);
        *reinterpret_cast<void***>(eax149) = reinterpret_cast<void**>(22);
        fun_10002844(ecx16);
        if (v150) {
            *reinterpret_cast<void***>(v151 + 0x70) = reinterpret_cast<void**>(reinterpret_cast<unsigned char>(*reinterpret_cast<void***>(v151 + 0x70)) & 0xfffffffd);
            goto addr_10005d68_213;
        }
    }
    addr_100068d1_215:
    ecx152 = reinterpret_cast<void**>(v7 ^ reinterpret_cast<uint32_t>(ebp5));
    eax153 = fun_10001cc4(ecx152, v60, ecx152, v60);
    return eax153;
    addr_10005d68_213:
    goto addr_100068d1_215;
}

void fun_100082c6(int32_t ecx) {
    goto fun_10007f80;
}

int32_t fun_10007400(struct s58* a1, uint32_t a2) {
    int32_t eax3;
    void** ecx4;
    void** eax5;
    void** v6;
    void** v7;
    void** v8;
    uint32_t* v9;

    eax3 = 1;
    if (a1->f4 & 6) {
        ecx4 = reinterpret_cast<void**>(*reinterpret_cast<uint32_t*>(a2 + 8) ^ a2);
        eax5 = fun_10001cc4(ecx4, __return_address());
        v6 = *reinterpret_cast<void***>(eax5 + 12);
        v7 = *reinterpret_cast<void***>(eax5 + 16);
        v8 = *reinterpret_cast<void***>(eax5 + 20);
        fun_10007370(v8, v7, v6);
        *v9 = a2;
        eax3 = 3;
    }
    return eax3;
}

void fun_100075f1(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6) {
    void** eax7;
    void** eax8;
    int32_t ebp9;
    int32_t ebp10;

    fun_10004570(0x1000c530, 8, __return_address());
    eax7 = fun_100036bd(ecx, 0x1000c530, 8, __return_address(), a2, a3, a4, a5, a6);
    eax8 = *reinterpret_cast<void***>(eax7 + 0x78);
    if (eax8) {
        *reinterpret_cast<uint32_t*>(ebp9 - 4) = 0;
        eax8();
        *reinterpret_cast<int32_t*>(ebp10 - 4) = -2;
    }
    fun_10008417(0x1000c530, 8, __return_address(), a2, a3);
    fun_100045b5(ecx, 0x1000c530, 8, __return_address(), a2, a3);
    goto 0x1000c530;
}

void fun_10007615() {
}

void fun_1000798e() {
}

void fun_10008b3b() {
    int32_t eax1;

    eax1 = g1000ddf0;
    if (eax1 != -1 && eax1 != -2) {
        CloseHandle(eax1);
    }
    return;
}

void fun_10008195() {
}

int32_t fun_100083c9() {
    int32_t eax1;
    void** ecx2;

    eax1 = 0;
    ecx2 = g0;
    if (reinterpret_cast<int1_t>(*reinterpret_cast<void***>(ecx2 + 4) == fun_10008300) && *reinterpret_cast<void***>(ecx2 + 8) == *reinterpret_cast<void***>(*reinterpret_cast<void***>(ecx2 + 12) + 12)) {
        eax1 = 1;
    }
    return eax1;
}

void fun_100083ec(int32_t ecx) {
    goto 0x10008400;
}

void fun_100085f5(int32_t ecx) {
}

void fun_10008641(int32_t ecx) {
}

void fun_10008781(int32_t ecx) {
}

void fun_10008d01() {
}

void fun_10008f64() {
}

int32_t fun_10008fa0(int32_t ecx, signed char* a2, signed char* a3) {
    int32_t eax4;
    signed char* edx5;
    signed char* esi6;
    int32_t ecx7;

    eax4 = 0;
    edx5 = a3;
    while (*edx5) {
        ++edx5;
        __asm__("bts [esp], eax");
    }
    esi6 = a2;
    ecx7 = -1;
    do {
        ++ecx7;
        *reinterpret_cast<signed char*>(&eax4) = *esi6;
        if (!*reinterpret_cast<signed char*>(&eax4)) 
            break;
        ++esi6;
    } while (!static_cast<int1_t>(0 >> eax4));
    return ecx7;
}

int32_t fun_10009070(unsigned char* a1, unsigned char* a2, int32_t a3) {
    int32_t ecx4;
    unsigned char* esi5;
    unsigned char* edi6;
    int32_t ecx7;
    unsigned char ah8;
    unsigned char al9;
    int1_t cf10;

    ecx4 = a3;
    if (!ecx4) 
        goto addr_100090ca_2;
    esi5 = a1;
    edi6 = a2;
    ecx7 = ecx4;
    do {
        ah8 = *esi5;
        al9 = *edi6;
        if (!ah8) 
            break;
        if (!al9) 
            break;
        ++esi5;
        ++edi6;
        if (ah8 >= 65 && ah8 <= 90) {
            ah8 = reinterpret_cast<unsigned char>(ah8 + 32);
        }
        if (al9 >= 65 && al9 <= 90) {
            al9 = reinterpret_cast<unsigned char>(al9 + 32);
        }
        cf10 = ah8 < al9;
        if (ah8 != al9) 
            goto addr_100090c1_11;
        --ecx7;
    } while (ecx7);
    ecx4 = 0;
    cf10 = ah8 < al9;
    if (ah8 == al9) {
        addr_100090ca_2:
        return ecx4;
    } else {
        addr_100090c1_11:
        ecx4 = -1;
        if (!cf10) {
            ecx4 = --1;
            goto addr_100090ca_2;
        }
    }
}

void fun_1000930f() {
    signed char* eax1;
    signed char* eax2;
    signed char al3;
    signed char* eax4;
    signed char* eax5;
    signed char al6;
    signed char* eax7;
    signed char* eax8;
    signed char al9;
    signed char* eax10;
    signed char* eax11;
    signed char al12;
    signed char* eax13;
    signed char* eax14;
    signed char al15;
    signed char* eax16;
    signed char* eax17;
    signed char al18;
    signed char* eax19;
    signed char* eax20;
    signed char al21;
    signed char* eax22;
    signed char* eax23;
    signed char al24;
    signed char* eax25;
    signed char* eax26;
    signed char al27;
    signed char* eax28;
    signed char* eax29;
    signed char al30;
    signed char* eax31;
    signed char* eax32;
    signed char al33;
    signed char* eax34;
    signed char* eax35;
    signed char al36;
    signed char* eax37;
    signed char* eax38;
    signed char al39;
    signed char* eax40;
    signed char* eax41;
    signed char al42;
    signed char* eax43;
    signed char* eax44;
    signed char al45;
    signed char* eax46;
    signed char* eax47;
    signed char al48;
    signed char* eax49;
    signed char* eax50;
    signed char al51;
    signed char* eax52;
    signed char* eax53;
    signed char al54;
    signed char* eax55;
    signed char* eax56;
    signed char al57;
    signed char* eax58;
    signed char* eax59;
    signed char al60;
    signed char* eax61;
    signed char* eax62;
    signed char al63;
    signed char* eax64;
    signed char* eax65;
    signed char al66;
    signed char* eax67;
    signed char* eax68;
    signed char al69;
    signed char* eax70;
    signed char* eax71;
    signed char al72;
    signed char* eax73;
    signed char* eax74;
    signed char al75;
    signed char* eax76;
    signed char* eax77;
    signed char al78;
    signed char* eax79;
    signed char* eax80;
    signed char al81;
    signed char* eax82;
    signed char* eax83;
    signed char al84;
    signed char* eax85;
    signed char* eax86;
    signed char al87;
    signed char* eax88;
    signed char* eax89;
    signed char al90;
    signed char* eax91;
    signed char* eax92;
    signed char al93;
    signed char* eax94;
    signed char* eax95;
    signed char al96;
    signed char* eax97;
    signed char* eax98;
    signed char al99;
    signed char* eax100;
    signed char* eax101;
    signed char al102;
    signed char* eax103;
    signed char* eax104;
    signed char al105;
    signed char* eax106;
    signed char* eax107;
    signed char al108;
    signed char* eax109;
    signed char* eax110;
    signed char al111;
    signed char* eax112;
    signed char* eax113;
    signed char al114;
    signed char* eax115;
    signed char* eax116;
    signed char al117;
    signed char* eax118;
    signed char* eax119;
    signed char al120;
    signed char* eax121;
    signed char* eax122;
    signed char al123;
    signed char* eax124;
    signed char* eax125;
    signed char al126;
    signed char* eax127;
    signed char* eax128;
    signed char al129;
    signed char* eax130;
    signed char* eax131;
    signed char al132;
    signed char* eax133;
    signed char* eax134;
    signed char al135;
    signed char* eax136;
    signed char* eax137;
    signed char al138;
    signed char* eax139;
    signed char* eax140;
    signed char al141;
    signed char* eax142;
    signed char* eax143;
    signed char al144;
    signed char* eax145;
    signed char* eax146;
    signed char al147;
    signed char* eax148;
    signed char* eax149;
    signed char al150;
    signed char* eax151;
    signed char* eax152;
    signed char al153;
    signed char* eax154;
    signed char* eax155;
    signed char al156;
    signed char* eax157;
    signed char* eax158;
    signed char al159;
    signed char* eax160;
    signed char* eax161;
    signed char al162;
    signed char* eax163;
    signed char* eax164;
    signed char al165;
    signed char* eax166;
    signed char* eax167;
    signed char al168;
    signed char* eax169;
    signed char* eax170;
    signed char al171;
    signed char* eax172;
    signed char* eax173;
    signed char al174;
    signed char* eax175;
    signed char* eax176;
    signed char al177;
    signed char* eax178;
    signed char* eax179;
    signed char al180;
    signed char* eax181;
    signed char* eax182;
    signed char al183;
    signed char* eax184;
    signed char* eax185;
    signed char al186;
    signed char* eax187;
    signed char* eax188;
    signed char al189;
    signed char* eax190;
    signed char* eax191;
    signed char al192;
    signed char* eax193;
    signed char* eax194;
    signed char al195;
    signed char* eax196;
    signed char* eax197;
    signed char al198;
    signed char* eax199;
    signed char* eax200;
    signed char al201;
    signed char* eax202;
    signed char* eax203;
    signed char al204;
    signed char* eax205;
    signed char* eax206;
    signed char al207;
    signed char* eax208;
    signed char* eax209;
    signed char al210;
    signed char* eax211;
    signed char* eax212;
    signed char al213;
    signed char* eax214;
    signed char* eax215;
    signed char al216;
    signed char* eax217;
    signed char* eax218;
    signed char al219;
    signed char* eax220;
    signed char* eax221;
    signed char al222;
    signed char* eax223;
    signed char* eax224;
    signed char al225;
    signed char* eax226;
    signed char* eax227;
    signed char al228;
    signed char* eax229;
    signed char* eax230;
    signed char al231;
    signed char* eax232;
    signed char* eax233;
    signed char al234;
    signed char* eax235;
    signed char* eax236;
    signed char al237;
    signed char* eax238;
    signed char* eax239;
    signed char al240;
    signed char* eax241;
    signed char* eax242;
    signed char al243;
    signed char* eax244;
    signed char* eax245;
    signed char al246;
    signed char* eax247;
    signed char* eax248;
    signed char al249;
    signed char* eax250;
    signed char* eax251;
    signed char al252;
    signed char* eax253;
    signed char* eax254;
    signed char al255;
    signed char* eax256;
    signed char* eax257;
    signed char al258;
    signed char* eax259;
    signed char* eax260;
    signed char al261;
    signed char* eax262;
    signed char* eax263;
    signed char al264;
    signed char* eax265;
    signed char* eax266;
    signed char al267;
    signed char* eax268;
    signed char* eax269;
    signed char al270;
    signed char* eax271;
    signed char* eax272;
    signed char al273;
    signed char* eax274;
    signed char* eax275;
    signed char al276;
    signed char* eax277;
    signed char* eax278;
    signed char al279;
    signed char* eax280;
    signed char* eax281;
    signed char al282;
    signed char* eax283;
    signed char* eax284;
    signed char al285;
    signed char* eax286;
    signed char* eax287;
    signed char al288;
    signed char* eax289;
    signed char* eax290;
    signed char al291;
    signed char* eax292;
    signed char* eax293;
    signed char al294;
    signed char* eax295;
    signed char* eax296;
    signed char al297;
    signed char* eax298;
    signed char* eax299;
    signed char al300;
    signed char* eax301;
    signed char* eax302;
    signed char al303;
    signed char* eax304;
    signed char* eax305;
    signed char al306;
    signed char* eax307;
    signed char* eax308;
    signed char al309;
    signed char* eax310;
    signed char* eax311;
    signed char al312;
    signed char* eax313;
    signed char* eax314;
    signed char al315;
    signed char* eax316;
    signed char* eax317;
    signed char al318;
    signed char* eax319;
    signed char* eax320;
    signed char al321;
    signed char* eax322;
    signed char* eax323;
    signed char al324;
    signed char* eax325;
    signed char* eax326;
    signed char al327;
    signed char* eax328;
    signed char* eax329;
    signed char al330;
    signed char* eax331;
    signed char* eax332;
    signed char al333;
    signed char* eax334;
    signed char* eax335;
    signed char al336;
    signed char* eax337;
    signed char* eax338;
    signed char al339;
    signed char* eax340;
    signed char* eax341;
    signed char al342;
    signed char* eax343;
    signed char* eax344;
    signed char al345;
    signed char* eax346;
    signed char* eax347;
    signed char al348;
    signed char* eax349;
    signed char* eax350;
    signed char al351;
    signed char* eax352;
    signed char* eax353;
    signed char al354;
    signed char* eax355;
    signed char* eax356;
    signed char al357;
    signed char* eax358;
    signed char* eax359;
    signed char al360;

    *eax1 = reinterpret_cast<signed char>(*eax2 + al3);
    *eax4 = reinterpret_cast<signed char>(*eax5 + al6);
    *eax7 = reinterpret_cast<signed char>(*eax8 + al9);
    *eax10 = reinterpret_cast<signed char>(*eax11 + al12);
    *eax13 = reinterpret_cast<signed char>(*eax14 + al15);
    *eax16 = reinterpret_cast<signed char>(*eax17 + al18);
    *eax19 = reinterpret_cast<signed char>(*eax20 + al21);
    *eax22 = reinterpret_cast<signed char>(*eax23 + al24);
    *eax25 = reinterpret_cast<signed char>(*eax26 + al27);
    *eax28 = reinterpret_cast<signed char>(*eax29 + al30);
    *eax31 = reinterpret_cast<signed char>(*eax32 + al33);
    *eax34 = reinterpret_cast<signed char>(*eax35 + al36);
    *eax37 = reinterpret_cast<signed char>(*eax38 + al39);
    *eax40 = reinterpret_cast<signed char>(*eax41 + al42);
    *eax43 = reinterpret_cast<signed char>(*eax44 + al45);
    *eax46 = reinterpret_cast<signed char>(*eax47 + al48);
    *eax49 = reinterpret_cast<signed char>(*eax50 + al51);
    *eax52 = reinterpret_cast<signed char>(*eax53 + al54);
    *eax55 = reinterpret_cast<signed char>(*eax56 + al57);
    *eax58 = reinterpret_cast<signed char>(*eax59 + al60);
    *eax61 = reinterpret_cast<signed char>(*eax62 + al63);
    *eax64 = reinterpret_cast<signed char>(*eax65 + al66);
    *eax67 = reinterpret_cast<signed char>(*eax68 + al69);
    *eax70 = reinterpret_cast<signed char>(*eax71 + al72);
    *eax73 = reinterpret_cast<signed char>(*eax74 + al75);
    *eax76 = reinterpret_cast<signed char>(*eax77 + al78);
    *eax79 = reinterpret_cast<signed char>(*eax80 + al81);
    *eax82 = reinterpret_cast<signed char>(*eax83 + al84);
    *eax85 = reinterpret_cast<signed char>(*eax86 + al87);
    *eax88 = reinterpret_cast<signed char>(*eax89 + al90);
    *eax91 = reinterpret_cast<signed char>(*eax92 + al93);
    *eax94 = reinterpret_cast<signed char>(*eax95 + al96);
    *eax97 = reinterpret_cast<signed char>(*eax98 + al99);
    *eax100 = reinterpret_cast<signed char>(*eax101 + al102);
    *eax103 = reinterpret_cast<signed char>(*eax104 + al105);
    *eax106 = reinterpret_cast<signed char>(*eax107 + al108);
    *eax109 = reinterpret_cast<signed char>(*eax110 + al111);
    *eax112 = reinterpret_cast<signed char>(*eax113 + al114);
    *eax115 = reinterpret_cast<signed char>(*eax116 + al117);
    *eax118 = reinterpret_cast<signed char>(*eax119 + al120);
    *eax121 = reinterpret_cast<signed char>(*eax122 + al123);
    *eax124 = reinterpret_cast<signed char>(*eax125 + al126);
    *eax127 = reinterpret_cast<signed char>(*eax128 + al129);
    *eax130 = reinterpret_cast<signed char>(*eax131 + al132);
    *eax133 = reinterpret_cast<signed char>(*eax134 + al135);
    *eax136 = reinterpret_cast<signed char>(*eax137 + al138);
    *eax139 = reinterpret_cast<signed char>(*eax140 + al141);
    *eax142 = reinterpret_cast<signed char>(*eax143 + al144);
    *eax145 = reinterpret_cast<signed char>(*eax146 + al147);
    *eax148 = reinterpret_cast<signed char>(*eax149 + al150);
    *eax151 = reinterpret_cast<signed char>(*eax152 + al153);
    *eax154 = reinterpret_cast<signed char>(*eax155 + al156);
    *eax157 = reinterpret_cast<signed char>(*eax158 + al159);
    *eax160 = reinterpret_cast<signed char>(*eax161 + al162);
    *eax163 = reinterpret_cast<signed char>(*eax164 + al165);
    *eax166 = reinterpret_cast<signed char>(*eax167 + al168);
    *eax169 = reinterpret_cast<signed char>(*eax170 + al171);
    *eax172 = reinterpret_cast<signed char>(*eax173 + al174);
    *eax175 = reinterpret_cast<signed char>(*eax176 + al177);
    *eax178 = reinterpret_cast<signed char>(*eax179 + al180);
    *eax181 = reinterpret_cast<signed char>(*eax182 + al183);
    *eax184 = reinterpret_cast<signed char>(*eax185 + al186);
    *eax187 = reinterpret_cast<signed char>(*eax188 + al189);
    *eax190 = reinterpret_cast<signed char>(*eax191 + al192);
    *eax193 = reinterpret_cast<signed char>(*eax194 + al195);
    *eax196 = reinterpret_cast<signed char>(*eax197 + al198);
    *eax199 = reinterpret_cast<signed char>(*eax200 + al201);
    *eax202 = reinterpret_cast<signed char>(*eax203 + al204);
    *eax205 = reinterpret_cast<signed char>(*eax206 + al207);
    *eax208 = reinterpret_cast<signed char>(*eax209 + al210);
    *eax211 = reinterpret_cast<signed char>(*eax212 + al213);
    *eax214 = reinterpret_cast<signed char>(*eax215 + al216);
    *eax217 = reinterpret_cast<signed char>(*eax218 + al219);
    *eax220 = reinterpret_cast<signed char>(*eax221 + al222);
    *eax223 = reinterpret_cast<signed char>(*eax224 + al225);
    *eax226 = reinterpret_cast<signed char>(*eax227 + al228);
    *eax229 = reinterpret_cast<signed char>(*eax230 + al231);
    *eax232 = reinterpret_cast<signed char>(*eax233 + al234);
    *eax235 = reinterpret_cast<signed char>(*eax236 + al237);
    *eax238 = reinterpret_cast<signed char>(*eax239 + al240);
    *eax241 = reinterpret_cast<signed char>(*eax242 + al243);
    *eax244 = reinterpret_cast<signed char>(*eax245 + al246);
    *eax247 = reinterpret_cast<signed char>(*eax248 + al249);
    *eax250 = reinterpret_cast<signed char>(*eax251 + al252);
    *eax253 = reinterpret_cast<signed char>(*eax254 + al255);
    *eax256 = reinterpret_cast<signed char>(*eax257 + al258);
    *eax259 = reinterpret_cast<signed char>(*eax260 + al261);
    *eax262 = reinterpret_cast<signed char>(*eax263 + al264);
    *eax265 = reinterpret_cast<signed char>(*eax266 + al267);
    *eax268 = reinterpret_cast<signed char>(*eax269 + al270);
    *eax271 = reinterpret_cast<signed char>(*eax272 + al273);
    *eax274 = reinterpret_cast<signed char>(*eax275 + al276);
    *eax277 = reinterpret_cast<signed char>(*eax278 + al279);
    *eax280 = reinterpret_cast<signed char>(*eax281 + al282);
    *eax283 = reinterpret_cast<signed char>(*eax284 + al285);
    *eax286 = reinterpret_cast<signed char>(*eax287 + al288);
    *eax289 = reinterpret_cast<signed char>(*eax290 + al291);
    *eax292 = reinterpret_cast<signed char>(*eax293 + al294);
    *eax295 = reinterpret_cast<signed char>(*eax296 + al297);
    *eax298 = reinterpret_cast<signed char>(*eax299 + al300);
    *eax301 = reinterpret_cast<signed char>(*eax302 + al303);
    *eax304 = reinterpret_cast<signed char>(*eax305 + al306);
    *eax307 = reinterpret_cast<signed char>(*eax308 + al309);
    *eax310 = reinterpret_cast<signed char>(*eax311 + al312);
    *eax313 = reinterpret_cast<signed char>(*eax314 + al315);
    *eax316 = reinterpret_cast<signed char>(*eax317 + al318);
    *eax319 = reinterpret_cast<signed char>(*eax320 + al321);
    *eax322 = reinterpret_cast<signed char>(*eax323 + al324);
    *eax325 = reinterpret_cast<signed char>(*eax326 + al327);
    *eax328 = reinterpret_cast<signed char>(*eax329 + al330);
    *eax331 = reinterpret_cast<signed char>(*eax332 + al333);
    *eax334 = reinterpret_cast<signed char>(*eax335 + al336);
    *eax337 = reinterpret_cast<signed char>(*eax338 + al339);
    *eax340 = reinterpret_cast<signed char>(*eax341 + al342);
    *eax343 = reinterpret_cast<signed char>(*eax344 + al345);
    *eax346 = reinterpret_cast<signed char>(*eax347 + al348);
    *eax349 = reinterpret_cast<signed char>(*eax350 + al351);
    *eax352 = reinterpret_cast<signed char>(*eax353 + al354);
    *eax355 = reinterpret_cast<signed char>(*eax356 + al357);
    *eax358 = reinterpret_cast<signed char>(*eax359 + al360);
}

void** fun_100020a9(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10) {
    void** esi11;
    void** ebp12;

    fun_10002099(ecx, esi11, ebp12, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10);
    if (*reinterpret_cast<unsigned char*>(&a2) & 1) {
        fun_10001cb9(ecx, ecx, esi11, ebp12, __return_address());
    }
    return ecx;
}

void fun_10002312() {
}

void** fun_10004a32(void** ecx, void** a2, void** a3, void** a4, void** a5, void** a6, void** a7, void** a8, void** a9, void** a10, void** a11, void** a12, void** a13) {
    void** esi14;
    void** ebp15;

    *reinterpret_cast<void***>(ecx) = reinterpret_cast<void**>("2J");
    fun_100049d4(ecx, esi14, ebp15, __return_address(), a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13);
    if (*reinterpret_cast<unsigned char*>(&a2) & 1) {
        fun_10001cb9(ecx, ecx, esi14, ebp15, __return_address());
    }
    return ecx;
}

void fun_10002da9() {
}

void fun_10003186() {
    goto 0x100031ad;
}

void fun_100037ee() {
}

void fun_100037fa() {
}

struct s137 {
    unsigned char f0;
    signed char f1;
    signed char f2;
    signed char f3;
};

int32_t fun_10003a60(unsigned char* a1, struct s137* a2) {
    unsigned char* edx3;
    struct s137* ecx4;
    unsigned char ax5;
    unsigned char eax6;
    uint32_t eax7;

    edx3 = a1;
    ecx4 = a2;
    if (reinterpret_cast<uint32_t>(edx3) & 3) {
        if (!(reinterpret_cast<uint32_t>(edx3) & 1)) {
            addr_10003acc_3:
            ax5 = *edx3;
            edx3 = edx3 + 2;
            if (ax5 != ecx4->f0) 
                goto 0x10003aa4;
        } else {
            ++edx3;
            if (*edx3 != ecx4->f0) 
                goto 0x10003aa4;
            ecx4 = reinterpret_cast<struct s137*>(&ecx4->f1);
            if (!*edx3) 
                goto addr_10003aa0_6;
            if (!(reinterpret_cast<uint32_t>(edx3) & 2)) 
                goto addr_10003a70_8; else 
                goto addr_10003acc_3;
        }
    } else {
        do {
            addr_10003a70_8:
            eax6 = *edx3;
            if (eax6 != ecx4->f0) 
                goto 0x10003aa4;
            if (!eax6) 
                goto addr_10003aa0_6;
            if (*reinterpret_cast<signed char*>(&eax6 + 1) != ecx4->f1) 
                goto 0x10003aa4;
            if (!*reinterpret_cast<signed char*>(&eax6 + 1)) 
                goto addr_10003aa0_6;
            eax7 = eax6 >> 16;
            if (*reinterpret_cast<signed char*>(&eax7) != ecx4->f2) 
                goto 0x10003aa4;
            if (!*reinterpret_cast<signed char*>(&eax7)) 
                goto addr_10003aa0_6;
            if (*reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(&eax7) + 1) != ecx4->f3) 
                goto 0x10003aa4;
            ++ecx4;
            edx3 = edx3 + 4;
        } while (*reinterpret_cast<signed char*>(reinterpret_cast<int32_t>(&eax7) + 1));
        goto addr_10003a9e_16;
    }
    if (!ax5) {
        addr_10003aa0_6:
        return 0;
    } else {
        if (*reinterpret_cast<signed char*>(&ax5 + 1) != ecx4->f1) 
            goto 0x10003aa4;
        if (!*reinterpret_cast<signed char*>(&ax5 + 1)) 
            goto addr_10003aa0_6;
    }
    ecx4 = reinterpret_cast<struct s137*>(&ecx4->f2);
    goto addr_10003a70_8;
    addr_10003a9e_16:
    goto addr_10003aa0_6;
}

void fun_100081db(void** ecx) {
    fun_10003e6f(ecx, 2);
    return;
}

void fun_100068e0(int32_t ecx) {
}

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

void fun_100082e0(struct s138* a1) {
    fun_100090d2();
    goto a1->f4;
}

void fun_10008c28() {
}

int32_t fun_10008300(struct s70* a1, int32_t a2) {
    int32_t eax3;
    void** ecx4;
    uint32_t v5;
    void** eax6;
    void** v7;
    void** v8;
    int32_t* v9;

    eax3 = 1;
    if (a1->f4 & 6) {
        ecx4 = reinterpret_cast<void**>(*reinterpret_cast<uint32_t*>(v5 - 4) ^ v5);
        eax6 = fun_10001cc4(ecx4, __return_address());
        v7 = *reinterpret_cast<void***>(eax6 + 40);
        v8 = *reinterpret_cast<void***>(eax6 + 36);
        fun_10008345(v8, v7);
        *v9 = a2;
        eax3 = 3;
    }
    return eax3;
}