bob.exe dumped to source c++

int64_t g140003298 = 0x1400026a0;

void fun_140002340(int64_t rcx) {
    int64_t* rbx2;

    rbx2 = reinterpret_cast<int64_t*>(0x1400037f8);
    while (reinterpret_cast<uint64_t>(rbx2) < 0x1400037f8) {
        if (*rbx2) {
            g140003298();
        }
        ++rbx2;
    }
    return;
}

int64_t fun_140001fb0(int64_t rcx);

int64_t fun_140001fec(int64_t rcx) {
    int64_t rax2;
    int64_t rax3;
    int64_t rax4;

    rax2 = fun_140001fb0(rcx);
    rax3 = -rax2;
    *reinterpret_cast<int32_t*>(&rax4) = reinterpret_cast<int32_t>(-(*reinterpret_cast<uint32_t*>(&rax3) - (*reinterpret_cast<uint32_t*>(&rax3) + reinterpret_cast<uint1_t>(*reinterpret_cast<uint32_t*>(&rax3) < *reinterpret_cast<uint32_t*>(&rax3) + reinterpret_cast<uint1_t>(!!rax2))))) - 1;
    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rax4) + 4) = 0;
    return rax4;
}

int32_t fun_1400020b4(int64_t rcx) {
    return 1;
}

int64_t _configure_narrow_argv = 0x4212;

int32_t fun_140002596(int64_t rcx) {
    goto _configure_narrow_argv;
}

int64_t InitializeSListHead = 0x4574;

void fun_1400020c4(int64_t rcx) {
    goto InitializeSListHead;
}

int32_t g140005014 = 1;

int32_t fun_140002108(int64_t rcx) {
    int32_t eax2;
    uint1_t zf3;

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

int64_t __setusermatherr = 0x41fe;

void fun_140002590(int64_t rcx) {
    goto __setusermatherr;
}

int64_t _initialize_narrow_environment = 0x422c;

void fun_14000259c(int64_t rcx) {
    goto _initialize_narrow_environment;
}

int32_t fun_1400020b0(int64_t rcx) {
    return 0;
}

int32_t fun_140002278(int64_t rcx) {
    return 0;
}

int64_t fun_140002550();

struct s0 {
    signed char[8] pad8;
    int64_t f8;
};

struct s0* g30;

int64_t g1400055b8;

signed char fun_140001db4(int64_t rcx, int64_t rdx, int64_t r8) {
    int64_t rax4;
    signed char al5;
    struct s0* rax6;
    int64_t rcx7;
    int1_t zf8;
    int64_t tmp64_9;

    rax4 = fun_140002550();
    if (!*reinterpret_cast<int32_t*>(&rax4)) {
        addr_140001de2_2:
        al5 = 0;
    } else {
        rax6 = g30;
        rcx7 = rax6->f8;
        do {
            zf8 = g1400055b8 == rcx7;
            if (zf8) {
                tmp64_9 = g1400055b8;
                g1400055b8 = rcx7;
                rcx7 = tmp64_9;
            }
            if (zf8)
                goto addr_140001de2_2;
        } while (rcx7);
        goto addr_140001de9_8;
    }
    addr_140001de4_9:
    return al5;
    addr_140001de9_8:
    al5 = 1;
    goto addr_140001de4_9;
}

int64_t _initterm_e = 0x427c;

int32_t fun_1400025ae(int64_t rcx, int64_t rdx, int64_t r8) {
    goto _initterm_e;
}

/* (image base) */
int16_t image_base_;

int32_t g14000003c;

struct s1 {
    int32_t f0;
    signed char[2] pad6;
    uint16_t f6;
    signed char[12] pad20;
    uint16_t f20;
    signed char[2] pad24;
    int16_t f24;
};

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

signed char fun_140001ec8(void** rcx, int64_t rdx, int64_t r8) {
    int1_t zf4;
    int64_t rcx5;
    struct s1* rcx6;
    signed char al7;
    uint64_t r8_8;
    int64_t rax9;
    struct s2* rdx10;
    int64_t rax11;
    struct s2* r9_12;
    uint64_t rcx13;
    uint64_t rax14;

    zf4 = image_base_ == 0x5a4d;
    if (!zf4 || ((rcx5 = g14000003c, rcx6 = reinterpret_cast<struct s1*>(rcx5 + 0x140000000), rcx6->f0 != 0x4550) || rcx6->f24 != 0x20b)) {
        al7 = 0;
    } else {
        r8_8 = reinterpret_cast<uint64_t>(rcx - 0x28000000);
        *reinterpret_cast<uint32_t*>(&rax9) = rcx6->f20;
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rax9) + 4) = 0;
        rdx10 = reinterpret_cast<struct s2*>(reinterpret_cast<int64_t>(&rcx6->f24) + rax9);
        *reinterpret_cast<uint32_t*>(&rax11) = rcx6->f6;
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rax11) + 4) = 0;
        r9_12 = reinterpret_cast<struct s2*>(reinterpret_cast<int64_t>(rdx10) + (rax11 + rax11 * 4) * 8);
        while (rdx10 != r9_12) {
            *reinterpret_cast<int32_t*>(&rcx13) = rdx10->f12;
            *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rcx13) + 4) = 0;
            if (r8_8 < rcx13)
                goto addr_140001f36_6;
            *reinterpret_cast<int32_t*>(&rax14) = rdx10->f8 + *reinterpret_cast<int32_t*>(&rcx13);
            *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rax14) + 4) = 0;
            if (r8_8 < rax14)
                goto addr_140001f3e_8;
            addr_140001f36_6:
            ++rdx10;
        }
        goto addr_140001f3c_9;
    }
    addr_140001f5b_10:
    return al7;
    addr_140001f3c_9:
    *reinterpret_cast<int32_t*>(&rdx10) = 0;
    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rdx10) + 4) = 0;
    addr_140001f3e_8:
    if (rdx10) {
        if (rdx10->f36 >= 0) {
            al7 = 1;
            goto addr_140001f5b_10;
        } else {
            al7 = 0;
            goto addr_140001f5b_10;
        }
    } else {
        al7 = 0;
        goto addr_140001f5b_10;
    }
}

int64_t _register_thread_local_exe_atexit_callback = 0x42d8;

void fun_1400025de(void** rcx, int64_t rdx, int64_t r8) {
    goto _register_thread_local_exe_atexit_callback;
}

int64_t _cexit = 0x42c4;

void fun_1400025d2(int64_t rcx, int64_t rdx, int64_t r8) {
    goto _cexit;
}

int64_t _c_exit = 0x42ce;

void fun_1400025d8() {
    goto _c_exit;
}

struct s3 {
    signed char[248] pad248;
    int64_t f248;
};

int64_t RtlCaptureContext = 0x4454;

int64_t RtlLookupFunctionEntry = 0x4468;

int64_t RtlVirtualUnwind = 0x4482;

void fun_140001d40(struct s3* rcx) {
    void* rsp2;
    int64_t rsi3;
    int32_t edi4;
    int64_t rax5;

    RtlCaptureContext();
    rsp2 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(__zero_stack_offset()) - 8 - 8 - 8 - 64 - 8 + 8);
    rsi3 = rcx->f248;
    edi4 = 0;
    do {
        rax5 = reinterpret_cast<int64_t>(RtlLookupFunctionEntry(rsi3, reinterpret_cast<int64_t>(rsp2) + 96));
        rsp2 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(rsp2) - 8 + 8);
        if (!rax5)
            break;
        RtlVirtualUnwind();
        rsp2 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(rsp2) - 8 + 8);
        ++edi4;
    } while (edi4 < 2);
    return;
}

int64_t SetUnhandledExceptionFilter = 0x44b2;

int64_t UnhandledExceptionFilter = 0x4496;

int64_t GetCurrentProcess = 0x44d0;

int64_t TerminateProcess = 0x44e4;

void fun_140001c38(int64_t rcx) {
    SetUnhandledExceptionFilter();
    UnhandledExceptionFilter(rcx);
    GetCurrentProcess(rcx);
    goto TerminateProcess;
}

uint64_t g140005020 = 0x202f;

uint32_t g140005624;

uint32_t g140005018 = 1;

uint32_t g14000501c = 2;

int64_t fun_1400023b8() {
    uint32_t eax1;
    int64_t rax2;
    uint32_t r8d3;
    uint32_t r8d4;

    if (__intrinsic() ^ 0x756e6547 | __intrinsic() ^ 0x6c65746e | __intrinsic() ^ 0x49656e69 || (g140005020 = 0xffffffffffffffff, eax1 = __intrinsic() & 0xfff3ff0, eax1 != 0x106c0) && (eax1 != 0x20660 && (eax1 != 0x20670 && ((*reinterpret_cast<uint32_t*>(&rax2) = eax1 - 0x30650, *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rax2) + 4) = 0, *reinterpret_cast<uint32_t*>(&rax2) > 32) || !static_cast<int1_t>(0x100010001 >> rax2))))) {
        r8d3 = g140005624;
    } else {
        r8d4 = g140005624;
        r8d3 = r8d4 | 1;
        g140005624 = r8d3;
    }
    if (__intrinsic() >= 7 && static_cast<int1_t>(__intrinsic() >> 9)) {
        g140005624 = r8d3 | 2;
    }
    g140005018 = 1;
    g14000501c = 2;
    if (!static_cast<int1_t>(__intrinsic() >> 20) || ((g140005018 = 2, g14000501c = 6, !static_cast<int1_t>(__intrinsic() >> 27)) || !static_cast<int1_t>(__intrinsic() >> 28))) {
        return 0;
    }
}

signed char fun_1400020d4() {
    return 1;
}

int32_t g140005030 = 1;

int64_t fun_140002550() {
    int64_t rax1;
    int1_t zf2;

    *reinterpret_cast<int32_t*>(&rax1) = 0;
    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rax1) + 4) = 0;
    zf2 = g140005030 == 0;
    *reinterpret_cast<unsigned char*>(&rax1) = reinterpret_cast<uint1_t>(!zf2);
    return rax1;
}

int64_t _initialize_onexit_table = 0x433c;

int32_t fun_1400025f6(int64_t rcx) {
    goto _initialize_onexit_table;
}

int64_t _crt_atexit = 0x4374;

int32_t fun_140002602() {
    goto _crt_atexit;
}

uint32_t g140005620;

void fun_140002124(int64_t rcx) {
    g140005620 = 0;
    return;
}

int64_t memset = 0x4192;

void fun_14000257e(void* rcx) {
    goto memset;
}

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

struct s5 {
    signed char[8] pad8;
    int64_t f8;
};

/*
 * ?flush@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@XZ
 * public: class std::basic_ostream<char,struct std::char_traits<char> > & __ptr64 __cdecl std::basic_ostream<char,struct std::char_traits<char> >::flush(void) __ptr64
 */
int64_t flush_basic_ostream_DU_char_traits_D_std_std_QEAAAEAV12_XZ = 0x3ff6;

/*
 * ?sputc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAAHD@Z
 * public: int __cdecl std::basic_streambuf<char,struct std::char_traits<char> >::sputc(char) __ptr64
 */
int64_t sputc_basic_streambuf_DU_char_traits_D_std_std_QEAAHD_Z = 0x3f76;

/*
 * ?sputn@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QEAA_JPEBD_J@Z
 * public: __int64 __cdecl std::basic_streambuf<char,struct std::char_traits<char> >::sputn(char const * __ptr64,__int64) __ptr64
 */
int64_t sputn_basic_streambuf_DU_char_traits_D_std_std_QEAA_JPEBD_J_Z = 0x3eae;

/*
 * ?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QEAAXH_N@Z
 * public: void __cdecl std::basic_ios<char,struct std::char_traits<char> >::setstate(int,bool) __ptr64
 */
int64_t setstate_basic_ios_DU_char_traits_D_std_std_QEAAXH_N_Z = 0x403a;

/*
 * ?uncaught_exception@std@@YA_NXZ
 * bool __cdecl std::uncaught_exception(void)
 */
int64_t uncaught_exception_std_YA_NXZ = 0x3e8c;

/*
 * ?_Osfx@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAXXZ
 * public: void __cdecl std::basic_ostream<char,struct std::char_traits<char> >::_Osfx(void) __ptr64
 */
int64_t _Osfx_basic_ostream_DU_char_traits_D_std_std_QEAAXXZ = 0x3fb8;

struct s6 {
    signed char[16] pad16;
    int64_t f16;
};

struct s4** fun_140001780(struct s4** rcx, void* rdx, int64_t r8, ...) {
    void* r15_4;
    struct s4** rsi5;
    int32_t ebx6;
    int64_t r14_7;
    struct s4* rcx8;
    int64_t rax9;
    int64_t rdi10;
    struct s4** r12_11;
    struct s4* rdx12;
    struct s5* rax13;
    struct s5** rcx14;
    int64_t rax15;
    unsigned char al16;
    struct s4** rcx17;
    int64_t rcx18;
    int64_t rdx19;
    int64_t rcx20;
    int32_t eax21;
    int64_t r8_22;
    int64_t rcx23;
    int64_t rax24;
    int64_t rcx25;
    int64_t rdx26;
    int64_t rcx27;
    int32_t eax28;
    int64_t rdx29;
    signed char al30;
    struct s6* rax31;

    r15_4 = rdx;
    rsi5 = rcx;
    ebx6 = 0;
    r14_7 = -1;
    do {
        ++r14_7;
    } while (*reinterpret_cast<signed char*>(reinterpret_cast<int64_t>(rdx) + r14_7));
    rcx8 = *rcx;
    rax9 = rcx8->f4;
    if (reinterpret_cast<uint1_t>(*reinterpret_cast<int64_t*>(rax9 + reinterpret_cast<int64_t>(rsi5) + 40) < 0) | reinterpret_cast<uint1_t>(*reinterpret_cast<int64_t*>(rax9 + reinterpret_cast<int64_t>(rsi5) + 40) == 0) || *reinterpret_cast<int64_t*>(rax9 + reinterpret_cast<int64_t>(rsi5) + 40) <= r14_7) {
        *reinterpret_cast<int32_t*>(&rdi10) = 0;
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rdi10) + 4) = 0;
    } else {
        rdi10 = *reinterpret_cast<int64_t*>(rax9 + reinterpret_cast<int64_t>(rsi5) + 40) - r14_7;
    }
    r12_11 = rsi5;
    rdx12 = rcx8;
    if (*reinterpret_cast<struct s5***>(rax9 + reinterpret_cast<int64_t>(rsi5) + 72)) {
        rax13 = **reinterpret_cast<struct s5***>(rax9 + reinterpret_cast<int64_t>(rsi5) + 72);
        rcx14 = *reinterpret_cast<struct s5***>(rax9 + reinterpret_cast<int64_t>(rsi5) + 72);
        rax13->f8(rcx14);
        rcx8 = *rsi5;
        rdx12 = rcx8;
    }
    rax15 = rcx8->f4;
    if (!*reinterpret_cast<int32_t*>(rax15 + reinterpret_cast<int64_t>(rsi5) + 16)) {
        if (!*reinterpret_cast<struct s4***>(rax15 + reinterpret_cast<int64_t>(rsi5) + 80) || *reinterpret_cast<struct s4***>(rax15 + reinterpret_cast<int64_t>(rsi5) + 80) == rsi5) {
            al16 = 1;
        } else {
            rcx17 = *reinterpret_cast<struct s4***>(rax15 + reinterpret_cast<int64_t>(rsi5) + 80);
            flush_basic_ostream_DU_char_traits_D_std_std_QEAAAEAV12_XZ(rcx17);
            rcx8 = *rsi5;
            al16 = reinterpret_cast<uint1_t>(*reinterpret_cast<int32_t*>(rcx8->f4 + reinterpret_cast<int64_t>(rsi5) + 16) == 0);
            rdx12 = rcx8;
        }
    } else {
        al16 = 0;
    }
    if (al16) {
        if ((*reinterpret_cast<uint32_t*>(rcx8->f4 + reinterpret_cast<int64_t>(rsi5) + 24) & 0x1c0) != 64) {
            while (!(reinterpret_cast<uint1_t>(rdi10 < 0) | reinterpret_cast<uint1_t>(rdi10 == 0))) {
                rcx18 = (*rsi5)->f4;
                *reinterpret_cast<uint32_t*>(&rdx19) = *reinterpret_cast<unsigned char*>(rcx18 + reinterpret_cast<int64_t>(rsi5) + 88);
                *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rdx19) + 4) = 0;
                rcx20 = *reinterpret_cast<int64_t*>(rcx18 + reinterpret_cast<int64_t>(rsi5) + 72);
                eax21 = reinterpret_cast<int32_t>(sputc_basic_streambuf_DU_char_traits_D_std_std_QEAAHD_Z(rcx20, rdx19));
                if (eax21 == -1)
                    goto addr_1400018c9_18;
                --rdi10;
            }
            rdx12 = *rsi5;
        }
        r8_22 = r14_7;
        rcx23 = *reinterpret_cast<int64_t*>(rdx12->f4 + reinterpret_cast<int64_t>(rsi5) + 72);
        rax24 = reinterpret_cast<int64_t>(sputn_basic_streambuf_DU_char_traits_D_std_std_QEAA_JPEBD_J_Z(rcx23, r15_4, r8_22));
        if (rax24 != r14_7) {
            addr_1400018c9_18:
            ebx6 = 4;
        } else {
            while (!(reinterpret_cast<uint1_t>(rdi10 < 0) | reinterpret_cast<uint1_t>(rdi10 == 0))) {
                rcx25 = (*rsi5)->f4;
                *reinterpret_cast<uint32_t*>(&rdx26) = *reinterpret_cast<unsigned char*>(rcx25 + reinterpret_cast<int64_t>(rsi5) + 88);
                *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rdx26) + 4) = 0;
                rcx27 = *reinterpret_cast<int64_t*>(rcx25 + reinterpret_cast<int64_t>(rsi5) + 72);
                eax28 = reinterpret_cast<int32_t>(sputc_basic_streambuf_DU_char_traits_D_std_std_QEAAHD_Z(rcx27, rdx26, r8_22));
                if (eax28 == -1)
                    goto addr_1400018c9_18;
                --rdi10;
            }
        }
        *reinterpret_cast<int64_t*>((*rsi5)->f4 + reinterpret_cast<int64_t>(rsi5) + 40) = 0;
    } else {
        ebx6 = 4;
    }
    *reinterpret_cast<int32_t*>(&rdx29) = ebx6;
    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rdx29) + 4) = 0;
    setstate_basic_ios_DU_char_traits_D_std_std_QEAAXH_N_Z();
    al30 = reinterpret_cast<signed char>(uncaught_exception_std_YA_NXZ());
    if (!al30) {
        _Osfx_basic_ostream_DU_char_traits_D_std_std_QEAAXXZ(r12_11, rdx29);
    }
    if (*reinterpret_cast<struct s6***>((*r12_11)->f4 + reinterpret_cast<int64_t>(r12_11) + 72)) {
        rax31 = **reinterpret_cast<struct s6***>((*r12_11)->f4 + reinterpret_cast<int64_t>(r12_11) + 72);
        rax31->f16();
    }
    return rsi5;
}

int64_t g1400055c8;

int32_t fun_1400025fc(int64_t rcx, int64_t rdx);

int64_t fun_140001fb0(int64_t rcx) {
    int1_t zf2;
    int32_t eax3;
    int64_t rdx4;

    zf2 = g1400055c8 == -1;
    if (!zf2) {
        eax3 = fun_1400025fc(0x1400055c8, rcx);
    } else {
        eax3 = fun_140002602();
    }
    *reinterpret_cast<int32_t*>(&rdx4) = 0;
    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rdx4) + 4) = 0;
    if (!eax3) {
        rdx4 = rcx;
    }
    return rdx4;
}

int32_t fun_14000260e(int64_t rcx);

int64_t IsDebuggerPresent = 0x458a;

void fun_14000212c(int32_t ecx, int64_t rdx, int64_t r8) {
    void* rsp4;
    void* rbp5;
    int32_t eax6;
    int64_t v7;
    int64_t rax8;
    void* rsp9;
    void* rcx10;
    int32_t eax11;
    int64_t rax12;
    int64_t rcx13;

    rsp4 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(__zero_stack_offset()) - 8);
    rbp5 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(rsp4) - 0x4c0);
    eax6 = fun_14000260e(23);
    if (eax6) {
        __asm__("int 0x29");
    }
    fun_140002124(3);
    fun_14000257e(reinterpret_cast<int64_t>(rbp5) - 16);
    RtlCaptureContext(reinterpret_cast<int64_t>(rbp5) - 16);
    rax8 = reinterpret_cast<int64_t>(RtlLookupFunctionEntry(v7, reinterpret_cast<int64_t>(rbp5) + 0x4d8));
    rsp9 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(rsp4) - 0x5c0 - 8 + 8 - 8 + 8 - 8 + 8 - 8 + 8 - 8 + 8);
    if (rax8) {
        RtlVirtualUnwind();
        rsp9 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(rsp9) - 8 + 8);
    }
    rcx10 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(rsp9) + 80);
    fun_14000257e(rcx10);
    eax11 = reinterpret_cast<int32_t>(IsDebuggerPresent(rcx10));
    SetUnhandledExceptionFilter();
    rax12 = reinterpret_cast<int64_t>(UnhandledExceptionFilter(reinterpret_cast<int64_t>(rsp9) - 8 + 8 - 8 + 8 - 8 + 8 + 64));
    if (!*reinterpret_cast<int32_t*>(&rax12) && eax11 != 1) {
        *reinterpret_cast<int32_t*>(&rcx13) = static_cast<int32_t>(rax12 + 3);
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rcx13) + 4) = 0;
        fun_140002124(rcx13);
    }
    return;
}

uint64_t* fun_1400020dc();

uint64_t* fun_1400020e4();

void fun_1400020ec(int64_t rcx) {
    uint64_t* rax2;
    uint64_t* rax3;

    rax2 = fun_1400020dc();
    *rax2 = *rax2 | 36;
    rax3 = fun_1400020e4();
    *rax3 = *rax3 | 2;
    return;
}

void** fun_140002114(void** rcx, int64_t rdx, int64_t r8) {
    return 0x140005670;
}

void fun_1400020d8(int64_t rcx) {
    return;
}

int64_t _configthreadlocale = 0x4306;

void fun_1400025e4(int64_t rcx) {
    goto _configthreadlocale;
}

int64_t _get_initial_narrow_environment = 0x424e;

int64_t fun_1400025a2(void** rcx, int64_t rdx, int64_t r8) {
    goto _get_initial_narrow_environment;
}

int64_t exit = 0x428a;

void fun_1400025b4(int64_t rcx, int64_t rdx, int64_t r8) {
    goto exit;
}

int64_t _exit = 0x4292;

void fun_1400025ba(int64_t rcx, int64_t rdx, int64_t r8) {
    goto _exit;
}

uint64_t g140005008 = 0x2b992ddfa232;

int64_t GetSystemTimeAsFileTime = 0x455a;

int64_t GetCurrentThreadId = 0x4544;

int64_t GetCurrentProcessId = 0x452e;

int64_t QueryPerformanceCounter = 0x4514;

int64_t g140005000 = 0xffffd466d2205dcd;

void fun_140002004(int64_t rcx, int64_t rdx, int64_t r8) {
    void* rbp4;
    uint64_t rax5;
    void* rcx6;
    int32_t eax7;
    uint64_t rax8;
    int32_t eax9;
    uint64_t rax10;
    uint64_t rax11;
    int32_t v12;
    uint64_t v13;

    rbp4 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(__zero_stack_offset()) - 8);
    rax5 = g140005008;
    if (rax5 == 0x2b992ddfa232) {
        rcx6 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(rbp4) + 24);
        GetSystemTimeAsFileTime(rcx6);
        eax7 = reinterpret_cast<int32_t>(GetCurrentThreadId(rcx6));
        *reinterpret_cast<int32_t*>(&rax8) = eax7;
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rax8) + 4) = 0;
        eax9 = reinterpret_cast<int32_t>(GetCurrentProcessId(rcx6));
        *reinterpret_cast<int32_t*>(&rax10) = eax9;
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rax10) + 4) = 0;
        QueryPerformanceCounter(reinterpret_cast<int64_t>(rbp4) + 32);
        *reinterpret_cast<int32_t*>(&rax11) = v12;
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rax11) + 4) = 0;
        rax5 = (rax11 << 32 ^ v13 ^ (rax8 ^ rax10) ^ reinterpret_cast<uint64_t>(reinterpret_cast<int64_t>(rbp4) + 16)) & 0xffffffffffff;
        if (rax5 == 0x2b992ddfa232) {
            rax5 = 0x2b992ddfa233;
        }
        g140005008 = rax5;
    }
    g140005000 = reinterpret_cast<int64_t>(~rax5);
    return;
}

void fun_140001f60(signed char cl, int64_t rdx, int64_t r8) {
    int64_t rax4;

    rax4 = fun_140002550();
    if (*reinterpret_cast<int32_t*>(&rax4) && !cl) {
        g1400055b8 = 0;
    }
    return;
}

int64_t _initterm = 0x4270;

void fun_1400025a8(void** rcx, int64_t rdx, int64_t r8) {
    goto _initterm;
}

void** fun_14000211c(void** rcx, int64_t rdx, int64_t r8) {
    return 0x140005668;
}

int64_t __p___argv = 0x42b6;

int64_t* fun_1400025cc(void** rcx, int64_t rdx, int64_t r8) {
    goto __p___argv;
}

int64_t __p___argc = 0x42a8;

int32_t* fun_1400025c6(void** rcx, int64_t rdx, int64_t r8) {
    goto __p___argc;
}

int64_t GetConsoleWindow = 0x3d78;

int64_t SetWindowTextA = 0x3da6;

/* ?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A */
struct s4** cout_std_3V_basic_ostream_DU_char_traits_D_std_1_A = reinterpret_cast<struct s4**>(0x3e50);

/*
 * ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@P6AAEAV01@AEAV01@@Z@Z
 * public: class std::basic_ostream<char,struct std::char_traits<char> > & __ptr64 __cdecl std::basic_ostream<char,struct std::char_traits<char> >::operator<<(class std::basic_ostream<char,struct std::char_traits<char> > & __ptr64 (__cdecl*)(class std::basic_ostream<char,struct std::char_traits<char> > & __ptr64)) __ptr64
 */
int64_t _6_basic_ostream_DU_char_traits_D_std_std_QEAAAEAV01_P6AAEAV01_AEAV01_Z_Z = 0x407a;

int64_t fun_140001950(int64_t rcx);

void fun_140001360(struct s4** rcx, int64_t rdx);

int64_t GetDC = 0x3dcc;

int64_t g140005630;

int64_t GetDeviceCaps = 0x3de0;

int32_t g140005638;

uint32_t g14000563c;

int64_t CreateCompatibleDC = 0x3dfc;

int64_t g140005650;

int64_t CreateCompatibleBitmap = 0x3e22;

int64_t g140005640;

int64_t SelectObject = 0x3e12;

int64_t g140005628;

int64_t BitBlt = 0x3e3c;

unsigned char* g140005648;

int64_t free = 0x41ca;

int64_t malloc = 0x41d2;

int64_t GetDIBits = 0x3df0;

int32_t g140005658;

int32_t g140005660;

int64_t Sleep = 0x3d70;

int64_t rand = 0x41c2;

int64_t SendInput = 0x3d9a;

/*
 * ??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV01@H@Z
 * public: class std::basic_ostream<char,struct std::char_traits<char> > & __ptr64 __cdecl std::basic_ostream<char,struct std::char_traits<char> >::operator<<(int) __ptr64
 */
int64_t _6_basic_ostream_DU_char_traits_D_std_std_QEAAAEAV01_H_Z = 0x40ce;

int32_t fun_140001080(int64_t rcx, int64_t rdx, int64_t r8) {
    void* rsp4;
    void* rbp5;
    int64_t rax6;
    struct s4** rcx7;
    void* rdx8;
    struct s4** rax9;
    struct s4** rcx10;
    void* rdx11;
    struct s4** rax12;
    struct s4** rcx13;
    void* rdx14;
    struct s4** rax15;
    struct s4** rax16;
    struct s4** rax17;
    struct s4** rax18;
    struct s4** rcx19;
    void* rdx20;
    struct s4** rax21;
    void* rbp22;
    int64_t rax23;
    int32_t eax24;
    int64_t rcx25;
    uint32_t eax26;
    int64_t rcx27;
    int64_t rax28;
    int64_t r8_29;
    int64_t rdx30;
    int64_t rcx31;
    int64_t rax32;
    int64_t rcx33;
    int64_t rax34;
    int64_t rcx35;
    int64_t rdx36;
    int64_t rcx37;
    unsigned char* rcx38;
    int64_t rax39;
    uint32_t eax40;
    int64_t rdx41;
    int64_t rcx42;
    unsigned char* rax43;
    int64_t rdx44;
    int64_t rcx45;
    int32_t eax46;
    int32_t eax47;
    int32_t tmp32_48;
    int64_t rcx49;
    unsigned char* rax50;
    int64_t rdx51;
    int64_t r9_52;
    int32_t ecx53;
    int32_t ecx54;
    int32_t ecx55;
    uint32_t eax56;
    int64_t rbx57;
    void* rdx58;
    int64_t rcx59;
    struct s4** rcx60;
    void* rdx61;
    struct s4** rax62;
    int64_t rdx63;
    int64_t rax64;

    rsp4 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(__zero_stack_offset()) - 8);
    rbp5 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(rsp4) - 87);
    __asm__("movdqa xmm0, [rbp-0x19]");
    __asm__("movdqa xmm1, [rbp-0x9]");
    __asm__("pxor xmm0, [rbp+0x17]");
    __asm__("movdqa [rbp-0x19], xmm0");
    __asm__("movdqa xmm0, [rbp+0x7]");
    __asm__("pxor xmm0, [rbp+0x37]");
    __asm__("pxor xmm1, [rbp+0x27]");
    __asm__("movdqa [rbp+0x7], xmm0");
    __asm__("movdqa [rbp-0x9], xmm1");
    rax6 = reinterpret_cast<int64_t>(GetConsoleWindow());
    SetWindowTextA(rax6, reinterpret_cast<int64_t>(rbp5) - 25);
    rcx7 = cout_std_3V_basic_ostream_DU_char_traits_D_std_1_A;
    rdx8 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(rbp5) - 25);
    __asm__("movdqa xmm0, [rbp-0x19]");
    __asm__("movdqa xmm1, [rbp-0x9]");
    __asm__("pxor xmm0, [rbp+0x17]");
    __asm__("pxor xmm1, [rbp+0x27]");
    __asm__("movdqa [rbp-0x9], xmm1");
    __asm__("movdqa [rbp-0x19], xmm0");
    rax9 = fun_140001780(rcx7, rdx8, r8, rcx7, rdx8, r8);
    _6_basic_ostream_DU_char_traits_D_std_std_QEAAAEAV01_P6AAEAV01_AEAV01_Z_Z(rax9, fun_140001950);
    rcx10 = cout_std_3V_basic_ostream_DU_char_traits_D_std_1_A;
    rdx11 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(rbp5) - 25);
    __asm__("movdqa xmm0, [rbp-0x19]");
    __asm__("movdqa xmm1, [rbp-0x9]");
    __asm__("pxor xmm0, [rbp+0x17]");
    __asm__("pxor xmm1, [rbp+0x27]");
    __asm__("movdqa [rbp-0x9], xmm1");
    __asm__("movdqa [rbp-0x19], xmm0");
    rax12 = fun_140001780(rcx10, rdx11, r8, rcx10, rdx11, r8);
    _6_basic_ostream_DU_char_traits_D_std_std_QEAAAEAV01_P6AAEAV01_AEAV01_Z_Z(rax12, fun_140001950);
    rcx13 = cout_std_3V_basic_ostream_DU_char_traits_D_std_1_A;
    rdx14 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(rbp5) + 23);
    __asm__("movdqa xmm0, [rbp+0x17]");
    __asm__("pxor xmm0, [rbp-0x19]");
    __asm__("movdqa [rbp+0x17], xmm0");
    rax15 = fun_140001780(rcx13, rdx14, r8, rcx13, rdx14, r8);
    rax16 = fun_140001780(rax15, "Dec  8 2019", r8, rax15, "Dec  8 2019", r8);
    rax17 = fun_140001780(rax16, " ", r8, rax16, " ", r8);
    rax18 = fun_140001780(rax17, "14:18:11", r8, rax17, "14:18:11", r8);
    _6_basic_ostream_DU_char_traits_D_std_std_QEAAAEAV01_P6AAEAV01_AEAV01_Z_Z(rax18, fun_140001950);
    rcx19 = cout_std_3V_basic_ostream_DU_char_traits_D_std_1_A;
    rdx20 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(rbp5) + 23);
    __asm__("movdqa xmm0, [rbp+0x17]");
    __asm__("pxor xmm0, [rbp-0x19]");
    __asm__("movdqa [rbp+0x17], xmm0");
    rax21 = fun_140001780(rcx19, rdx20, r8, rcx19, rdx20, r8);
    _6_basic_ostream_DU_char_traits_D_std_std_QEAAAEAV01_P6AAEAV01_AEAV01_Z_Z(rax21, fun_140001950);
    fun_140001360(rax21, fun_140001950);
    rbp22 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(rsp4) - 0x90 - 8 + 8 - 8 + 8 - 8 + 8 - 8 + 8 - 8 + 8 - 8 + 8 - 8 + 8 - 8 + 8 - 8 + 8 - 8 + 8 - 8 + 8 - 8 + 8 - 8 + 8 - 8 + 8 - 8 - 8 - 8 - 8 - 8 - 64);
    rax23 = reinterpret_cast<int64_t>(GetDC());
    g140005630 = rax23;
    eax24 = reinterpret_cast<int32_t>(GetDeviceCaps(rax23, 8));
    rcx25 = g140005630;
    g140005638 = eax24;
    eax26 = reinterpret_cast<uint32_t>(GetDeviceCaps(rcx25, 10));
    rcx27 = g140005630;
    g14000563c = eax26;
    rax28 = reinterpret_cast<int64_t>(CreateCompatibleDC(rcx27, 10));
    *reinterpret_cast<uint32_t*>(&r8_29) = g14000563c;
    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&r8_29) + 4) = 0;
    *reinterpret_cast<int32_t*>(&rdx30) = g140005638;
    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rdx30) + 4) = 0;
    rcx31 = g140005630;
    g140005650 = rax28;
    rax32 = reinterpret_cast<int64_t>(CreateCompatibleBitmap(rcx31, rdx30, r8_29));
    __asm__("xorps xmm0, xmm0");
    g140005640 = rax32;
    __asm__("movdqu [rbp-0x10], xmm0");
    while (1) {
        rcx33 = g140005650;
        rax34 = reinterpret_cast<int64_t>(SelectObject(rcx33, rax32, r8_29));
        rcx35 = g140005650;
        g140005628 = rax34;
        BitBlt(rcx35);
        rdx36 = g140005628;
        rcx37 = g140005650;
        SelectObject(rcx37, rdx36);
        rcx38 = g140005648;
        free(rcx38, rdx36);
        *reinterpret_cast<int32_t*>(&rax39) = g140005638;
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rax39) + 4) = 0;
        eax40 = g14000563c;
        *reinterpret_cast<int32_t*>(&rdx41) = __intrinsic();
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rdx41) + 4) = 0;
        *reinterpret_cast<uint32_t*>(&rcx42) = eax40 * static_cast<int32_t>(rax39 * 4);
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rcx42) + 4) = 0;
        if (__intrinsic()) {
            rcx42 = -1;
        }
        rax43 = reinterpret_cast<unsigned char*>(malloc(rcx42, rdx41));
        rdx44 = g140005640;
        rcx45 = g140005650;
        g140005648 = rax43;
        GetDIBits(rcx45, rdx44);
        eax46 = g140005658;
        eax47 = eax46 * g140005638;
        tmp32_48 = eax47 + g140005660;
        rcx49 = tmp32_48 << 2;
        rax50 = g140005648;
        *reinterpret_cast<uint32_t*>(&rdx51) = *reinterpret_cast<unsigned char*>(rcx49 + reinterpret_cast<int64_t>(rax50) + 2);
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rdx51) + 4) = 0;
        *reinterpret_cast<uint32_t*>(&r8_29) = *reinterpret_cast<unsigned char*>(rcx49 + reinterpret_cast<int64_t>(rax50) + 1);
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&r8_29) + 4) = 0;
        *reinterpret_cast<uint32_t*>(&r9_52) = *reinterpret_cast<unsigned char*>(rcx49 + reinterpret_cast<int64_t>(rax50));
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&r9_52) + 4) = 0;
        ecx53 = static_cast<int32_t>(rdx51 - 0xfa) * static_cast<int32_t>(rdx51 - 0xdc);
        if (!reinterpret_cast<uint1_t>(reinterpret_cast<uint1_t>(ecx53 < 0) | reinterpret_cast<uint1_t>(ecx53 == 0)) || ((ecx54 = static_cast<int32_t>(r8_29 - 50) * static_cast<int32_t>(r8_29 - 20), !reinterpret_cast<uint1_t>(reinterpret_cast<uint1_t>(ecx54 < 0) | reinterpret_cast<uint1_t>(ecx54 == 0))) || (ecx55 = static_cast<int32_t>(r9_52 - 50) * static_cast<int32_t>(r9_52 - 20), !reinterpret_cast<uint1_t>(reinterpret_cast<uint1_t>(ecx55 < 0) | reinterpret_cast<uint1_t>(ecx55 == 0))))) {
            addr_1400016f4_6:
            Sleep(1, rdx51, r8_29);
            rax32 = g140005640;
            continue;
        } else {
            do {
                eax56 = reinterpret_cast<uint32_t>(rand());
            } while (reinterpret_cast<int32_t>(eax56) >= reinterpret_cast<int32_t>(0x7ffc));
            *reinterpret_cast<uint32_t*>(&rbx57) = eax56 & 0x80000003;
            *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rbx57) + 4) = 0;
            if (__intrinsic())
                goto addr_1400015b7_10;
        }
        addr_1400015be_11:
        __asm__("xorps xmm0, xmm0");
        __asm__("xorps xmm1, xmm1");
        rdx58 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(rbp22) - 80);
        __asm__("movdqu [rbp-0x4c], xmm0");
        __asm__("movdqu [rbp-0x38], xmm1");
        SendInput(1, rdx58, 40);
        *reinterpret_cast<int32_t*>(&rcx59) = static_cast<int32_t>(rbx57 + 1);
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rcx59) + 4) = 0;
        Sleep(rcx59, rdx58, 40);
        __asm__("xorps xmm0, xmm0");
        __asm__("xorps xmm1, xmm1");
        *reinterpret_cast<uint32_t*>(&r8_29) = 40;
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&r8_29) + 4) = 0;
        __asm__("movdqu [rbp-0x4c], xmm0");
        __asm__("movdqu [rbp-0x38], xmm1");
        SendInput(1, reinterpret_cast<int64_t>(rbp22) - 80, 40);
        rcx60 = cout_std_3V_basic_ostream_DU_char_traits_D_std_1_A;
        rdx61 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(rbp22) - 0x80);
        __asm__("movups xmm0, [rsp+0x50]");
        __asm__("movups xmm1, [rsp+0x60]");
        __asm__("movups xmm2, [rsp+0x70]");
        __asm__("pxor xmm1, [rbp+0x10]");
        __asm__("pxor xmm0, [rbp+0x0]");
        __asm__("pxor xmm2, [rbp+0x20]");
        __asm__("movdqa [rbp-0x70], xmm1");
        __asm__("movdqa [rbp-0x80], xmm0");
        __asm__("movdqa [rbp-0x60], xmm2");
        rax62 = fun_140001780(rcx60, rdx61, 40, rcx60, rdx61, 40);
        *reinterpret_cast<int32_t*>(&rdx63) = static_cast<int32_t>(rbx57 + 1);
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rdx63) + 4) = 0;
        rax64 = reinterpret_cast<int64_t>(_6_basic_ostream_DU_char_traits_D_std_std_QEAAAEAV01_H_Z(rax62, rdx63, 40));
        rdx51 = reinterpret_cast<int64_t>(fun_140001950);
        _6_basic_ostream_DU_char_traits_D_std_std_QEAAAEAV01_P6AAEAV01_AEAV01_Z_Z(rax64, fun_140001950, 40);
        goto addr_1400016f4_6;
        addr_1400015b7_10:
        *reinterpret_cast<uint32_t*>(&rbx57) = (*reinterpret_cast<uint32_t*>(&rbx57) - 1 | 0xfffffffc) + 1;
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rbx57) + 4) = 0;
        goto addr_1400015be_11;
    }
}

int64_t GetModuleHandleW = 0x459e;

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

struct s8 {
    int32_t f0;
    signed char[20] pad24;
    int16_t f24;
    signed char[106] pad132;
    uint32_t f132;
    signed char[112] pad248;
    int32_t f248;
};

signed char fun_140002280(int64_t rcx, int64_t rdx, int64_t r8) {
    struct s7* rax4;
    struct s8* rcx5;
    signed char al6;

    rax4 = reinterpret_cast<struct s7*>(GetModuleHandleW());
    if (!rax4 || (rax4->f0 != 0x5a4d || ((rcx5 = reinterpret_cast<struct s8*>(rax4->f60 + reinterpret_cast<int64_t>(rax4)), rcx5->f0 != 0x4550) || (rcx5->f24 != 0x20b || (rcx5->f132 <= 14 || !rcx5->f248))))) {
        al6 = 0;
    } else {
        al6 = 1;
    }
    return al6;
}

unsigned char g1400055c0;

signed char fun_140001f84(signed char cl, signed char dl, int64_t r8) {
    int1_t zf4;

    zf4 = g1400055c0 == 0;
    if (zf4 || !dl) {
        fun_1400020d4();
        fun_1400020d4();
    }
    return 1;
}

int64_t _register_onexit_function = 0x4358;

int32_t fun_1400025fc(int64_t rcx, int64_t rdx) {
    goto _register_onexit_function;
}

int64_t terminate = 0x4382;

void fun_140002608() {
    goto terminate;
}

int64_t _seh_filter_exe = 0x41dc;

void fun_140002584(int64_t rcx, int32_t** rdx) {
    goto _seh_filter_exe;
}

struct s9 {
    int32_t f0;
    signed char[20] pad24;
    int32_t f24;
    signed char[4] pad32;
    int32_t f32;
};

int64_t __current_exception = 0x415e;

struct s9** fun_140002572() {
    goto __current_exception;
}

int64_t __current_exception_context = 0x4174;

int64_t* fun_140002578() {
    goto __current_exception_context;
}

int64_t IsProcessorFeaturePresent = 0x44f8;

int32_t fun_14000260e(int64_t rcx) {
    goto IsProcessorFeaturePresent;
}

int64_t _set_app_type = 0x41ee;

void fun_14000258a(int64_t rcx) {
    goto _set_app_type;
}

int32_t fun_1400020bc(int64_t rcx) {
    return 0x4000;
}

int64_t _set_fmode = 0x429a;

void fun_1400025c0(int64_t rcx) {
    goto _set_fmode;
}

int64_t __p__commode = 0x432c;

int32_t* fun_1400025f0(int64_t rcx) {
    goto __p__commode;
}

signed char g1400055c1;

struct s10 {
    int32_t f0;
    signed char[2] pad6;
    uint16_t f6;
    signed char[12] pad20;
    uint16_t f20;
    signed char[2] pad24;
    int16_t f24;
};

int64_t g1400055d8;

int64_t g1400055f0;

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

signed char fun_140001e3c(uint32_t ecx, int64_t rdx, int64_t r8) {
    int1_t zf4;
    signed char al5;
    int1_t zf6;
    int64_t rcx7;
    struct s10* rcx8;
    int64_t rax9;
    int32_t eax10;
    int32_t eax11;
    int64_t v12;
    int64_t rax13;
    struct s11* rdx14;
    int64_t rax15;
    struct s11* r9_16;
    uint64_t rcx17;
    uint64_t rax18;

    zf4 = g1400055c1 == 0;
    if (!zf4) {
        addr_140001eb4_2:
        al5 = 1;
    } else {
        if (ecx > 1) {
            fun_14000212c(5, rdx, r8);
            zf6 = image_base_ == 0x5a4d;
            if (!zf6)
                goto addr_140001f55_6;
            rcx7 = g14000003c;
            rcx8 = reinterpret_cast<struct s10*>(rcx7 + 0x140000000);
            if (rcx8->f0 != 0x4550)
                goto addr_140001f55_6;
            if (rcx8->f24 != 0x20b)
                goto addr_140001f55_6; else
                goto addr_140001f01_9;
        } else {
            rax9 = fun_140002550();
            if (!*reinterpret_cast<int32_t*>(&rax9) || ecx) {
                __asm__("movdqa xmm0, [rip+0x14a5]");
                __asm__("movdqu [rip+0x3731], xmm0");
                g1400055d8 = -1;
                __asm__("movdqu [rip+0x373a], xmm0");
                g1400055f0 = -1;
                goto addr_140001ead_12;
            }
            eax10 = fun_1400025f6(0x1400055c8);
            if (eax10 || (eax11 = fun_1400025f6(0x1400055e0), !!eax11)) {
                al5 = 0;
            } else {
                addr_140001ead_12:
                g1400055c1 = 1;
                goto addr_140001eb4_2;
            }
        }
    }
    return al5;
    addr_140001f55_6:
    addr_140001f5b_16:
    goto v12;
    addr_140001f01_9:
    *reinterpret_cast<uint32_t*>(&rax13) = rcx8->f20;
    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rax13) + 4) = 0;
    rdx14 = reinterpret_cast<struct s11*>(reinterpret_cast<int64_t>(&rcx8->f24) + rax13);
    *reinterpret_cast<uint32_t*>(&rax15) = rcx8->f6;
    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rax15) + 4) = 0;
    r9_16 = reinterpret_cast<struct s11*>(reinterpret_cast<int64_t>(rdx14) + (rax15 + rax15 * 4) * 8);
    while (rdx14 != r9_16) {
        *reinterpret_cast<int32_t*>(&rcx17) = rdx14->f12;
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rcx17) + 4) = 0;
        if (0xfffffffec0000005 < rcx17)
            goto addr_140001f36_19;
        *reinterpret_cast<int32_t*>(&rax18) = rdx14->f8 + *reinterpret_cast<int32_t*>(&rcx17);
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rax18) + 4) = 0;
        if (0xfffffffec0000005 < rax18)
            goto addr_140001f3e_21;
        addr_140001f36_19:
        ++rdx14;
    }
    *reinterpret_cast<int32_t*>(&rdx14) = 0;
    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rdx14) + 4) = 0;
    addr_140001f3e_21:
    if (rdx14) {
        if (rdx14->f36 >= 0) {
            goto addr_140001f5b_16;
        } else {
            goto addr_140001f5b_16;
        }
    } else {
        goto addr_140001f5b_16;
    }
}

uint64_t* fun_1400020dc() {
    return 0x140005610;
}

uint64_t* fun_1400020e4() {
    return 0x140005618;
}

void fun_1400022d4() {
    goto SetUnhandledExceptionFilter;
}

signed char fun_140001df0(int32_t ecx, int64_t rdx, int64_t r8) {
    uint32_t eax4;
    signed char al5;
    signed char al6;
    signed char al7;

    eax4 = g1400055c0;
    if (!ecx) {
        eax4 = 1;
    }
    g1400055c0 = *reinterpret_cast<unsigned char*>(&eax4);
    fun_1400023b8();
    al5 = fun_1400020d4();
    if (al5) {
        al6 = fun_1400020d4();
        if (al6) {
            al7 = 1;
        } else {
            fun_1400020d4();
            goto addr_140001e1b_7;
        }
    } else {
        addr_140001e1b_7:
        al7 = 0;
    }
    return al7;
}

void fun_140001360(struct s4** rcx, int64_t rdx) {
    void* rbp3;
    int64_t rax4;
    int32_t eax5;
    int64_t rcx6;
    uint32_t eax7;
    int64_t rcx8;
    int64_t rax9;
    int64_t r8_10;
    int64_t rdx11;
    int64_t rcx12;
    int64_t rax13;
    int64_t rcx14;
    int64_t rax15;
    int64_t rcx16;
    int64_t rdx17;
    int64_t rcx18;
    unsigned char* rcx19;
    int64_t rax20;
    uint32_t eax21;
    int64_t rdx22;
    int64_t rcx23;
    unsigned char* rax24;
    int64_t rdx25;
    int64_t rcx26;
    int32_t eax27;
    int32_t eax28;
    int32_t tmp32_29;
    int64_t rcx30;
    unsigned char* rax31;
    int64_t rdx32;
    int64_t r9_33;
    int32_t ecx34;
    int32_t ecx35;
    int32_t ecx36;
    uint32_t eax37;
    int64_t rbx38;
    void* rdx39;
    int64_t rcx40;
    struct s4** rcx41;
    void* rdx42;
    struct s4** rax43;
    int64_t rdx44;
    int64_t rax45;

    rbp3 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(__zero_stack_offset()) - 8 - 8 - 8 - 8 - 8 - 64);
    rax4 = reinterpret_cast<int64_t>(GetDC());
    g140005630 = rax4;
    eax5 = reinterpret_cast<int32_t>(GetDeviceCaps(rax4, 8));
    rcx6 = g140005630;
    g140005638 = eax5;
    eax7 = reinterpret_cast<uint32_t>(GetDeviceCaps(rcx6, 10));
    rcx8 = g140005630;
    g14000563c = eax7;
    rax9 = reinterpret_cast<int64_t>(CreateCompatibleDC(rcx8, 10));
    *reinterpret_cast<uint32_t*>(&r8_10) = g14000563c;
    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&r8_10) + 4) = 0;
    *reinterpret_cast<int32_t*>(&rdx11) = g140005638;
    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rdx11) + 4) = 0;
    rcx12 = g140005630;
    g140005650 = rax9;
    rax13 = reinterpret_cast<int64_t>(CreateCompatibleBitmap(rcx12, rdx11, r8_10));
    __asm__("xorps xmm0, xmm0");
    g140005640 = rax13;
    __asm__("movdqu [rbp-0x10], xmm0");
    while (1) {
        rcx14 = g140005650;
        rax15 = reinterpret_cast<int64_t>(SelectObject(rcx14, rax13, r8_10));
        rcx16 = g140005650;
        g140005628 = rax15;
        BitBlt(rcx16);
        rdx17 = g140005628;
        rcx18 = g140005650;
        SelectObject(rcx18, rdx17);
        rcx19 = g140005648;
        free(rcx19, rdx17);
        *reinterpret_cast<int32_t*>(&rax20) = g140005638;
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rax20) + 4) = 0;
        eax21 = g14000563c;
        *reinterpret_cast<int32_t*>(&rdx22) = __intrinsic();
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rdx22) + 4) = 0;
        *reinterpret_cast<uint32_t*>(&rcx23) = eax21 * static_cast<int32_t>(rax20 * 4);
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rcx23) + 4) = 0;
        if (__intrinsic()) {
            rcx23 = -1;
        }
        rax24 = reinterpret_cast<unsigned char*>(malloc(rcx23, rdx22));
        rdx25 = g140005640;
        rcx26 = g140005650;
        g140005648 = rax24;
        GetDIBits(rcx26, rdx25);
        eax27 = g140005658;
        eax28 = eax27 * g140005638;
        tmp32_29 = eax28 + g140005660;
        rcx30 = tmp32_29 << 2;
        rax31 = g140005648;
        *reinterpret_cast<uint32_t*>(&rdx32) = *reinterpret_cast<unsigned char*>(rcx30 + reinterpret_cast<int64_t>(rax31) + 2);
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rdx32) + 4) = 0;
        *reinterpret_cast<uint32_t*>(&r8_10) = *reinterpret_cast<unsigned char*>(rcx30 + reinterpret_cast<int64_t>(rax31) + 1);
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&r8_10) + 4) = 0;
        *reinterpret_cast<uint32_t*>(&r9_33) = *reinterpret_cast<unsigned char*>(rcx30 + reinterpret_cast<int64_t>(rax31));
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&r9_33) + 4) = 0;
        ecx34 = static_cast<int32_t>(rdx32 - 0xfa) * static_cast<int32_t>(rdx32 - 0xdc);
        if (!reinterpret_cast<uint1_t>(reinterpret_cast<uint1_t>(ecx34 < 0) | reinterpret_cast<uint1_t>(ecx34 == 0)) || ((ecx35 = static_cast<int32_t>(r8_10 - 50) * static_cast<int32_t>(r8_10 - 20), !reinterpret_cast<uint1_t>(reinterpret_cast<uint1_t>(ecx35 < 0) | reinterpret_cast<uint1_t>(ecx35 == 0))) || (ecx36 = static_cast<int32_t>(r9_33 - 50) * static_cast<int32_t>(r9_33 - 20), !reinterpret_cast<uint1_t>(reinterpret_cast<uint1_t>(ecx36 < 0) | reinterpret_cast<uint1_t>(ecx36 == 0))))) {
            addr_1400016f4_5:
            Sleep(1, rdx32, r8_10);
            rax13 = g140005640;
            continue;
        } else {
            do {
                eax37 = reinterpret_cast<uint32_t>(rand());
            } while (reinterpret_cast<int32_t>(eax37) >= reinterpret_cast<int32_t>(0x7ffc));
            *reinterpret_cast<uint32_t*>(&rbx38) = eax37 & 0x80000003;
            *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rbx38) + 4) = 0;
            if (__intrinsic())
                goto addr_1400015b7_9;
        }
        addr_1400015be_10:
        __asm__("xorps xmm0, xmm0");
        __asm__("xorps xmm1, xmm1");
        rdx39 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(rbp3) - 80);
        __asm__("movdqu [rbp-0x4c], xmm0");
        __asm__("movdqu [rbp-0x38], xmm1");
        SendInput(1, rdx39, 40);
        *reinterpret_cast<int32_t*>(&rcx40) = static_cast<int32_t>(rbx38 + 1);
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rcx40) + 4) = 0;
        Sleep(rcx40, rdx39, 40);
        __asm__("xorps xmm0, xmm0");
        __asm__("xorps xmm1, xmm1");
        *reinterpret_cast<uint32_t*>(&r8_10) = 40;
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&r8_10) + 4) = 0;
        __asm__("movdqu [rbp-0x4c], xmm0");
        __asm__("movdqu [rbp-0x38], xmm1");
        SendInput(1, reinterpret_cast<int64_t>(rbp3) - 80, 40);
        rcx41 = cout_std_3V_basic_ostream_DU_char_traits_D_std_1_A;
        rdx42 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(rbp3) - 0x80);
        __asm__("movups xmm0, [rsp+0x50]");
        __asm__("movups xmm1, [rsp+0x60]");
        __asm__("movups xmm2, [rsp+0x70]");
        __asm__("pxor xmm1, [rbp+0x10]");
        __asm__("pxor xmm0, [rbp+0x0]");
        __asm__("pxor xmm2, [rbp+0x20]");
        __asm__("movdqa [rbp-0x70], xmm1");
        __asm__("movdqa [rbp-0x80], xmm0");
        __asm__("movdqa [rbp-0x60], xmm2");
        rax43 = fun_140001780(rcx41, rdx42, 40, rcx41, rdx42, 40);
        *reinterpret_cast<int32_t*>(&rdx44) = static_cast<int32_t>(rbx38 + 1);
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rdx44) + 4) = 0;
        rax45 = reinterpret_cast<int64_t>(_6_basic_ostream_DU_char_traits_D_std_std_QEAAAEAV01_H_Z(rax43, rdx44, 40));
        rdx32 = reinterpret_cast<int64_t>(fun_140001950);
        _6_basic_ostream_DU_char_traits_D_std_std_QEAAAEAV01_P6AAEAV01_AEAV01_Z_Z(rax45, fun_140001950, 40);
        goto addr_1400016f4_5;
        addr_1400015b7_9:
        *reinterpret_cast<uint32_t*>(&rbx38) = (*reinterpret_cast<uint32_t*>(&rbx38) - 1 | 0xfffffffc) + 1;
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rbx38) + 4) = 0;
        goto addr_1400015be_10;
    }
}

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

struct s12 {
    signed char[8] pad8;
    int64_t f8;
    struct s13* f16;
};

struct s14 {
    unsigned char f0;
    signed char[3] pad4;
    int32_t f4;
    int32_t f8;
};

int64_t g1400051d8 = 0;

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

int64_t g140005050 = 0;

uint64_t g140005160 = 0;

int32_t g140005040 = 0;

int32_t g140005044 = 0;

int32_t g140005058 = 0;

int64_t g140005060 = 0;

void fun_140002634(uint64_t rcx, struct s12* rdx, struct s14* r8) {
    uint64_t r9_4;
    uint64_t r10_5;
    int64_t rcx6;
    int64_t rax7;
    uint64_t rcx8;
    int1_t zf9;
    int32_t eax10;
    int64_t rax11;

    r9_4 = rcx;
    r10_5 = rcx;
    if (r8->f0 & 4) {
        r10_5 = r8->f4 + rcx & reinterpret_cast<uint64_t>(static_cast<int64_t>(-r8->f8));
    }
    *reinterpret_cast<int32_t*>(&rcx6) = rdx->f16->f8;
    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rcx6) + 4) = 0;
    if (*reinterpret_cast<unsigned char*>(rcx6 + rdx->f8 + 3) & 15) {
        *reinterpret_cast<uint32_t*>(&rax7) = static_cast<uint32_t>(*reinterpret_cast<unsigned char*>(rcx6 + rdx->f8 + 3)) & 0xfffffff0;
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rax7) + 4) = 0;
        r9_4 = r9_4 + rax7;
    }
    rcx8 = r9_4 ^ *reinterpret_cast<uint64_t*>((r8->f0 & 0xfffffff8) + r10_5);
    zf9 = rcx8 == g140005008;
    if (zf9) {
        __asm__("rol rcx, 0x10");
        if (*reinterpret_cast<uint16_t*>(&rcx8) & 0xffff) {
            __asm__("ror rcx, 0x10");
        } else {
            return;
        }
    }
    eax10 = fun_14000260e(23);
    if (eax10) {
        __asm__("int 0x29");
    }
    fun_140001d40(0x1400050e0);
    g1400051d8 = reinterpret_cast<int64_t>(__return_address());
    g140005178 = reinterpret_cast<void*>(reinterpret_cast<int64_t>(__zero_stack_offset()) - 8 + 8 - 56 - 8 + 8 - 8 + 8 + 56 + 8);
    rax11 = g1400051d8;
    g140005050 = rax11;
    g140005160 = rcx8;
    g140005040 = 0xc0000409;
    g140005044 = 1;
    g140005058 = 1;
    g140005060 = 2;
    fun_140001c38("@P");
    return;
}

int64_t GetSystemMetrics = 0x3db8;

int32_t g14000565c;

void fun_140001000() {
    int32_t eax1;

    eax1 = reinterpret_cast<int32_t>(GetSystemMetrics());
    g14000565c = eax1;
    return;
}

void fun_1400024d7() {
    uint64_t rax1;
    int32_t eax2;
    int32_t edx3;
    uint64_t rax4;
    uint64_t rdx5;
    unsigned char bl6;
    unsigned char bl7;
    uint32_t eax8;
    uint32_t eax9;
    unsigned char r11b10;
    uint32_t eax11;
    uint32_t r11d12;
    uint32_t ebx13;

    *reinterpret_cast<int32_t*>(&rax1) = eax2 + edx3;
    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rax1) + 4) = 0;
    rax4 = rdx5 << 32 | rax1;
    if ((*reinterpret_cast<unsigned char*>(&rax4) & bl6) != bl7)
        goto 0x14000253e;
    eax8 = g14000501c;
    eax9 = eax8 | 8;
    g140005018 = 3;
    g14000501c = eax9;
    if (!(r11b10 & 32))
        goto 0x14000253e;
    g140005018 = 5;
    eax11 = eax9 | 32;
    g14000501c = eax11;
    if ((r11d12 & 0xd0030000) != 0xd0030000)
        goto 0x14000253e;
    g140005018 = ebx13;
    g14000501c = eax11 | 64;
}

int32_t g140005664;

void fun_140001020() {
    int32_t eax1;

    eax1 = reinterpret_cast<int32_t>(GetSystemMetrics(1));
    g140005664 = eax1;
    return;
}

void fun_14000237c() {
    int64_t* rbx1;

    rbx1 = reinterpret_cast<int64_t*>(0x140003808);
    while (reinterpret_cast<uint64_t>(rbx1) < 0x140003808) {
        if (*rbx1) {
            g140003298();
        }
        ++rbx1;
    }
    return;
}

void fun_140001040() {
    int32_t eax1;
    int32_t edx2;

    eax1 = g14000565c;
    __asm__("cdq ");
    g140005660 = eax1 - edx2 >> 1;
    return;
}

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

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

void fun_140001708(struct s15*** rcx) {
    signed char al2;
    struct s15** rcx3;
    struct s16* rax4;

    al2 = reinterpret_cast<signed char>(uncaught_exception_std_YA_NXZ());
    if (!al2) {
        rcx3 = *rcx;
        _Osfx_basic_ostream_DU_char_traits_D_std_std_QEAAXXZ(rcx3);
    }
    if (*reinterpret_cast<struct s16***>((**rcx)->f4 + reinterpret_cast<int64_t>(*rcx) + 72)) {
        rax4 = **reinterpret_cast<struct s16***>((**rcx)->f4 + reinterpret_cast<int64_t>(*rcx) + 72);
        rax4->f16();
    }
    return;
}

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

struct s18 {
    signed char[16] pad16;
    int64_t f16;
};

void fun_14000174f(struct s17*** rcx) {
    struct s18* rax2;

    if (*reinterpret_cast<struct s18***>((**rcx)->f4 + reinterpret_cast<int64_t>(*rcx) + 72)) {
        rax2 = **reinterpret_cast<struct s18***>((**rcx)->f4 + reinterpret_cast<int64_t>(*rcx) + 72);
        rax2->f16();
    }
    return;
}

void fun_1400018e4() {
}

/*
 * ?widen@?$basic_ios@DU?$char_traits@D@std@@@std@@QEBADD@Z
 * public: char __cdecl std::basic_ios<char,struct std::char_traits<char> >::widen(char)const __ptr64
 */
int64_t widen_basic_ios_DU_char_traits_D_std_std_QEBADD_Z = 0x3ef6;

/*
 * ?put@?$basic_ostream@DU?$char_traits@D@std@@@std@@QEAAAEAV12@D@Z
 * public: class std::basic_ostream<char,struct std::char_traits<char> > & __ptr64 __cdecl std::basic_ostream<char,struct std::char_traits<char> >::put(char) __ptr64
 */
int64_t put_basic_ostream_DU_char_traits_D_std_std_QEAAAEAV12_D_Z = 0x3f32;

int64_t fun_140001950(int64_t rcx) {
    unsigned char al2;
    int64_t rdx3;

    al2 = reinterpret_cast<unsigned char>(widen_basic_ios_DU_char_traits_D_std_std_QEBADD_Z());
    *reinterpret_cast<uint32_t*>(&rdx3) = al2;
    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rdx3) + 4) = 0;
    put_basic_ostream_DU_char_traits_D_std_std_QEAAAEAV12_D_Z(rcx, rdx3);
    flush_basic_ostream_DU_char_traits_D_std_std_QEAAAEAV12_XZ(rcx, rdx3);
    return rcx;
}

void fun_1400019c4() {
    int32_t eax1;
    int64_t rcx2;
    int32_t eax3;
    int32_t* rax4;
    int64_t rdx5;
    int64_t r8_6;
    signed char al7;
    int32_t eax8;
    int64_t rcx9;
    int32_t eax10;
    int32_t eax11;
    int32_t eax12;
    int64_t rcx13;
    signed char al14;
    int32_t eax15;
    int64_t rdx16;
    int64_t r8_17;
    int64_t v18;

    fun_14000258a(1);
    eax1 = fun_1400020bc(1);
    *reinterpret_cast<int32_t*>(&rcx2) = eax1;
    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rcx2) + 4) = 0;
    fun_1400025c0(rcx2);
    eax3 = fun_1400020b0(rcx2);
    rax4 = fun_1400025f0(rcx2);
    *rax4 = eax3;
    al7 = fun_140001e3c(1, rdx5, r8_6);
    if (al7 && (fun_140002340(1), fun_140001fec(fun_14000237c), eax8 = fun_1400020b4(fun_14000237c), *reinterpret_cast<int32_t*>(&rcx9) = eax8, *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rcx9) + 4) = 0, eax10 = fun_140002596(rcx9), !eax10)) {
        fun_1400020c4(rcx9);
        eax11 = fun_140002108(rcx9);
        if (eax11) {
            rcx9 = reinterpret_cast<int64_t>(fun_1400020b0);
            fun_140002590(fun_1400020b0);
        }
        fun_1400020d8(rcx9);
        fun_1400020d8(rcx9);
        eax12 = fun_1400020b0(rcx9);
        *reinterpret_cast<int32_t*>(&rcx13) = eax12;
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rcx13) + 4) = 0;
        fun_1400025e4(rcx13);
        al14 = fun_1400020d4();
        if (al14) {
            fun_14000259c(rcx13);
        }
        fun_1400020b0(rcx13);
        eax15 = fun_140002278(rcx13);
        if (!eax15) {
            return;
        }
    }
    fun_14000212c(7, rdx16, r8_17);
    fun_1400020ec(7);
    goto v18;
}

int64_t _set_new_mode = 0x431c;

void fun_140001a8c(int64_t rcx) {
    fun_1400022d4();
    fun_1400020b0(rcx);
    goto _set_new_mode;
}

int32_t g1400055b0;

int64_t fun_140001bd6(int64_t rcx, int64_t rdx, int64_t r8) {
    int64_t rbx4;
    int32_t eax5;
    signed char al6;
    int64_t rcx7;
    signed char al8;
    int64_t rsi9;
    signed char al10;
    void** rcx11;
    int32_t eax12;
    void** rax13;
    signed char al14;
    void** rax15;
    signed char al16;
    int64_t rax17;
    int64_t* rax18;
    int64_t rbx19;
    int32_t* rax20;
    int64_t rcx21;
    int32_t eax22;
    signed char al23;
    int64_t rcx24;
    signed char v25;
    int64_t rax26;

    *reinterpret_cast<int32_t*>(&rbx4) = eax5;
    al6 = fun_140002280(rcx, rdx, r8);
    if (!al6) {
        while (1) {
            *reinterpret_cast<int32_t*>(&rcx7) = *reinterpret_cast<int32_t*>(&rbx4);
            *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rcx7) + 4) = 0;
            fun_1400025ba(rcx7, rdx, r8);
            fun_140002004(rcx7, rdx, r8);
            al8 = fun_140001df0(1, rdx, r8);
            if (!al8) {
                fun_14000212c(7, rdx, r8);
                goto addr_140001c0a_5;
            } else {
                *reinterpret_cast<signed char*>(&rsi9) = 0;
                al10 = fun_140001db4(1, rdx, r8);
                *reinterpret_cast<signed char*>(&rbx4) = al10;
                *reinterpret_cast<int32_t*>(&rcx11) = g1400055b0;
                *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rcx11) + 4) = 0;
                if (*reinterpret_cast<int32_t*>(&rcx11) == 1) {
                    addr_140001c0a_5:
                    fun_14000212c(7, rdx, r8);
                } else {
                    if (*reinterpret_cast<int32_t*>(&rcx11)) {
                        *reinterpret_cast<signed char*>(&rsi9) = 1;
                    } else {
                        g1400055b0 = 1;
                        eax12 = fun_1400025ae(0x1400032d8, 0x1400032f0, r8);
                        if (eax12)
                            goto addr_140001b0c_10;
                        rdx = 0x1400032d0;
                        rcx11 = reinterpret_cast<void**>(0x1400032a0);
                        fun_1400025a8(0x1400032a0, 0x1400032d0, r8);
                        g1400055b0 = 2;
                    }
                    *reinterpret_cast<signed char*>(&rcx11) = *reinterpret_cast<signed char*>(&rbx4);
                    fun_140001f60(*reinterpret_cast<signed char*>(&rcx11), rdx, r8);
                    rax13 = fun_140002114(rcx11, rdx, r8);
                    if (*reinterpret_cast<void***>(rax13) && (rcx11 = rax13, al14 = fun_140001ec8(rcx11, rdx, r8), !!al14)) {
                        *reinterpret_cast<int32_t*>(&r8) = 0;
                        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&r8) + 4) = 0;
                        *reinterpret_cast<int32_t*>(&rdx) = 2;
                        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rdx) + 4) = 0;
                        *reinterpret_cast<int32_t*>(&rcx11) = 0;
                        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rcx11) + 4) = 0;
                        g140003298();
                    }
                    rax15 = fun_14000211c(rcx11, rdx, r8);
                    if (*reinterpret_cast<void***>(rax15) && (rcx11 = rax15, al16 = fun_140001ec8(rcx11, rdx, r8), !!al16)) {
                        rcx11 = *reinterpret_cast<void***>(rax15);
                        fun_1400025de(rcx11, rdx, r8);
                    }
                    rax17 = fun_1400025a2(rcx11, rdx, r8);
                    rax18 = fun_1400025cc(rcx11, rdx, r8);
                    rbx19 = *rax18;
                    rax20 = fun_1400025c6(rcx11, rdx, r8);
                    r8 = rax17;
                    rdx = rbx19;
                    *reinterpret_cast<int32_t*>(&rcx21) = *rax20;
                    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rcx21) + 4) = 0;
                    eax22 = fun_140001080(rcx21, rdx, r8);
                    *reinterpret_cast<int32_t*>(&rbx4) = eax22;
                    al23 = fun_140002280(rcx21, rdx, r8);
                    if (al23)
                        break;
                }
                *reinterpret_cast<int32_t*>(&rcx24) = *reinterpret_cast<int32_t*>(&rbx4);
                *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rcx24) + 4) = 0;
                fun_1400025b4(rcx24, rdx, r8);
            }
        }
    } else {
        if (!v25) {
            fun_1400025d8();
        }
        *reinterpret_cast<int32_t*>(&rax26) = *reinterpret_cast<int32_t*>(&rbx4);
        *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rax26) + 4) = 0;
        goto addr_140001bef_21;
    }
    if (!*reinterpret_cast<signed char*>(&rsi9)) {
        fun_1400025d2(rcx21, rdx, r8);
    }
    fun_140001f84(1, 0, r8);
    *reinterpret_cast<int32_t*>(&rax26) = *reinterpret_cast<int32_t*>(&rbx4);
    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rax26) + 4) = 0;
    addr_140001bef_21:
    return rax26;
    addr_140001b0c_10:
    *reinterpret_cast<int32_t*>(&rax26) = 0xff;
    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rax26) + 4) = 0;
    goto addr_140001bef_21;
}

int64_t __CxxFrameHandler4 = 0x411e;

void fun_140002560() {
    goto __CxxFrameHandler4;
}

void fun_140001f59() {
}

void fun_1400026a0() {
    int64_t rax1;

    goto rax1;
}

void fun_140001060() {
    int32_t eax1;
    int32_t edx2;

    eax1 = g140005664;
    __asm__("cdq ");
    g140005658 = eax1 - edx2 >> 1;
    return;
}

int64_t __std_terminate = 0x4134;

void fun_140002566() {
    goto __std_terminate;
}

void fun_1400026b0() {
    goto 0x140001750;
}

struct s19 {
    signed char[56] pad56;
    struct s14* f56;
};

int64_t fun_140002614() {
    struct s14* r8_1;
    struct s19* r9_2;
    uint64_t rdx3;
    struct s12* r9_4;

    r8_1 = r9_2->f56;
    fun_140002634(rdx3, r9_4, r8_1);
    return 1;
}

struct s20 {
    struct s9* f0;
    int64_t f8;
};

int64_t fun_1400022e4(struct s20* rcx) {
    struct s9* rbx2;
    int64_t rdx3;
    struct s9** rax4;
    int64_t rbx5;
    int64_t* rax6;

    rbx2 = rcx->f0;
    if (rbx2->f0 != 0xe06d7363 || (rbx2->f24 != 4 || (*reinterpret_cast<int32_t*>(&rdx3) = rbx2->f32, *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rdx3) + 4) = 0, static_cast<uint32_t>(rdx3 - 0x19930520) > 2) && *reinterpret_cast<int32_t*>(&rdx3) != 0x1994000)) {
        return 0;
    } else {
        rax4 = fun_140002572();
        *rax4 = rbx2;
        rbx5 = rcx->f8;
        rax6 = fun_140002578();
        *rax6 = rbx5;
        fun_140002608();
    }
}

int64_t __C_specific_handler = 0x4146;

void fun_14000256c() {
    goto __C_specific_handler;
}

void fun_1400026bc() {
    goto 0x140001710;
}

int64_t fun_1400026c8() {
    setstate_basic_ios_DU_char_traits_D_std_std_QEAAXH_N_Z();
    return 0;
}

void fun_140002703(int32_t** rcx, int64_t rdx) {
    int64_t rcx3;

    *reinterpret_cast<int32_t*>(&rcx3) = **rcx;
    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rcx3) + 4) = 0;
    fun_140002584(rcx3, rcx);
    return;
}

int64_t fun_140002721(int32_t** rcx, int64_t rdx) {
    int32_t ecx3;
    int64_t rax4;

    ecx3 = 0;
    *reinterpret_cast<unsigned char*>(&ecx3) = reinterpret_cast<uint1_t>(**rcx == 0xc0000005);
    *reinterpret_cast<int32_t*>(&rax4) = ecx3;
    *reinterpret_cast<int32_t*>(reinterpret_cast<int64_t>(&rax4) + 4) = 0;
    return rax4;
}

void fun_140002739() {
    signed char* rax1;
    signed char* rax2;
    signed char al3;
    signed char* rax4;
    signed char* rax5;
    signed char al6;
    signed char* rax7;
    signed char* rax8;
    signed char al9;
    signed char* rax10;
    signed char* rax11;
    signed char al12;
    signed char* rax13;
    signed char* rax14;
    signed char al15;
    signed char* rax16;
    signed char* rax17;
    signed char al18;
    signed char* rax19;
    signed char* rax20;
    signed char al21;
    signed char* rax22;
    signed char* rax23;
    signed char al24;
    signed char* rax25;
    signed char* rax26;
    signed char al27;
    signed char* rax28;
    signed char* rax29;
    signed char al30;
    signed char* rax31;
    signed char* rax32;
    signed char al33;
    signed char* rax34;
    signed char* rax35;
    signed char al36;
    signed char* rax37;
    signed char* rax38;
    signed char al39;
    signed char* rax40;
    signed char* rax41;
    signed char al42;
    signed char* rax43;
    signed char* rax44;
    signed char al45;
    signed char* rax46;
    signed char* rax47;
    signed char al48;
    signed char* rax49;
    signed char* rax50;
    signed char al51;
    signed char* rax52;
    signed char* rax53;
    signed char al54;
    signed char* rax55;
    signed char* rax56;
    signed char al57;
    signed char* rax58;
    signed char* rax59;
    signed char al60;
    signed char* rax61;
    signed char* rax62;
    signed char al63;
    signed char* rax64;
    signed char* rax65;
    signed char al66;
    signed char* rax67;
    signed char* rax68;
    signed char al69;
    signed char* rax70;
    signed char* rax71;
    signed char al72;
    signed char* rax73;
    signed char* rax74;
    signed char al75;
    signed char* rax76;
    signed char* rax77;
    signed char al78;
    signed char* rax79;
    signed char* rax80;
    signed char al81;
    signed char* rax82;
    signed char* rax83;
    signed char al84;
    signed char* rax85;
    signed char* rax86;
    signed char al87;
    signed char* rax88;
    signed char* rax89;
    signed char al90;
    signed char* rax91;
    signed char* rax92;
    signed char al93;
    signed char* rax94;
    signed char* rax95;
    signed char al96;
    signed char* rax97;
    signed char* rax98;
    signed char al99;
    signed char* rax100;
    signed char* rax101;
    signed char al102;
    signed char* rax103;
    signed char* rax104;
    signed char al105;
    signed char* rax106;
    signed char* rax107;
    signed char al108;
    signed char* rax109;
    signed char* rax110;
    signed char al111;
    signed char* rax112;
    signed char* rax113;
    signed char al114;
    signed char* rax115;
    signed char* rax116;
    signed char al117;
    signed char* rax118;
    signed char* rax119;
    signed char al120;
    signed char* rax121;
    signed char* rax122;
    signed char al123;
    signed char* rax124;
    signed char* rax125;
    signed char al126;
    signed char* rax127;
    signed char* rax128;
    signed char al129;
    signed char* rax130;
    signed char* rax131;
    signed char al132;
    signed char* rax133;
    signed char* rax134;
    signed char al135;
    signed char* rax136;
    signed char* rax137;
    signed char al138;
    signed char* rax139;
    signed char* rax140;
    signed char al141;
    signed char* rax142;
    signed char* rax143;
    signed char al144;
    signed char* rax145;
    signed char* rax146;
    signed char al147;
    signed char* rax148;
    signed char* rax149;
    signed char al150;
    signed char* rax151;
    signed char* rax152;
    signed char al153;
    signed char* rax154;
    signed char* rax155;
    signed char al156;
    signed char* rax157;
    signed char* rax158;
    signed char al159;
    signed char* rax160;
    signed char* rax161;
    signed char al162;
    signed char* rax163;
    signed char* rax164;
    signed char al165;
    signed char* rax166;
    signed char* rax167;
    signed char al168;
    signed char* rax169;
    signed char* rax170;
    signed char al171;
    signed char* rax172;
    signed char* rax173;
    signed char al174;
    signed char* rax175;
    signed char* rax176;
    signed char al177;
    signed char* rax178;
    signed char* rax179;
    signed char al180;
    signed char* rax181;
    signed char* rax182;
    signed char al183;
    signed char* rax184;
    signed char* rax185;
    signed char al186;
    signed char* rax187;
    signed char* rax188;
    signed char al189;
    signed char* rax190;
    signed char* rax191;
    signed char al192;
    signed char* rax193;
    signed char* rax194;
    signed char al195;
    signed char* rax196;
    signed char* rax197;
    signed char al198;
    signed char* rax199;
    signed char* rax200;
    signed char al201;
    signed char* rax202;
    signed char* rax203;
    signed char al204;
    signed char* rax205;
    signed char* rax206;
    signed char al207;
    signed char* rax208;
    signed char* rax209;
    signed char al210;
    signed char* rax211;
    signed char* rax212;
    signed char al213;
    signed char* rax214;
    signed char* rax215;
    signed char al216;
    signed char* rax217;
    signed char* rax218;
    signed char al219;
    signed char* rax220;
    signed char* rax221;
    signed char al222;
    signed char* rax223;
    signed char* rax224;
    signed char al225;
    signed char* rax226;
    signed char* rax227;
    signed char al228;
    signed char* rax229;
    signed char* rax230;
    signed char al231;
    signed char* rax232;
    signed char* rax233;
    signed char al234;
    signed char* rax235;
    signed char* rax236;
    signed char al237;
    signed char* rax238;
    signed char* rax239;
    signed char al240;
    signed char* rax241;
    signed char* rax242;
    signed char al243;
    signed char* rax244;
    signed char* rax245;
    signed char al246;
    signed char* rax247;
    signed char* rax248;
    signed char al249;
    signed char* rax250;
    signed char* rax251;
    signed char al252;
    signed char* rax253;
    signed char* rax254;
    signed char al255;
    signed char* rax256;
    signed char* rax257;
    signed char al258;
    signed char* rax259;
    signed char* rax260;
    signed char al261;
    signed char* rax262;
    signed char* rax263;
    signed char al264;
    signed char* rax265;
    signed char* rax266;
    signed char al267;
    signed char* rax268;
    signed char* rax269;
    signed char al270;
    signed char* rax271;
    signed char* rax272;
    signed char al273;
    signed char* rax274;
    signed char* rax275;
    signed char al276;
    signed char* rax277;
    signed char* rax278;
    signed char al279;
    signed char* rax280;
    signed char* rax281;
    signed char al282;
    signed char* rax283;
    signed char* rax284;
    signed char al285;
    signed char* rax286;
    signed char* rax287;
    signed char al288;
    signed char* rax289;
    signed char* rax290;
    signed char al291;
    signed char* rax292;
    signed char* rax293;
    signed char al294;
    signed char* rax295;
    signed char* rax296;
    signed char al297;

    *rax1 = reinterpret_cast<signed char>(*rax2 + al3);
    *rax4 = reinterpret_cast<signed char>(*rax5 + al6);
    *rax7 = reinterpret_cast<signed char>(*rax8 + al9);
    *rax10 = reinterpret_cast<signed char>(*rax11 + al12);
    *rax13 = reinterpret_cast<signed char>(*rax14 + al15);
    *rax16 = reinterpret_cast<signed char>(*rax17 + al18);
    *rax19 = reinterpret_cast<signed char>(*rax20 + al21);
    *rax22 = reinterpret_cast<signed char>(*rax23 + al24);
    *rax25 = reinterpret_cast<signed char>(*rax26 + al27);
    *rax28 = reinterpret_cast<signed char>(*rax29 + al30);
    *rax31 = reinterpret_cast<signed char>(*rax32 + al33);
    *rax34 = reinterpret_cast<signed char>(*rax35 + al36);
    *rax37 = reinterpret_cast<signed char>(*rax38 + al39);
    *rax40 = reinterpret_cast<signed char>(*rax41 + al42);
    *rax43 = reinterpret_cast<signed char>(*rax44 + al45);
    *rax46 = reinterpret_cast<signed char>(*rax47 + al48);
    *rax49 = reinterpret_cast<signed char>(*rax50 + al51);
    *rax52 = reinterpret_cast<signed char>(*rax53 + al54);
    *rax55 = reinterpret_cast<signed char>(*rax56 + al57);
    *rax58 = reinterpret_cast<signed char>(*rax59 + al60);
    *rax61 = reinterpret_cast<signed char>(*rax62 + al63);
    *rax64 = reinterpret_cast<signed char>(*rax65 + al66);
    *rax67 = reinterpret_cast<signed char>(*rax68 + al69);
    *rax70 = reinterpret_cast<signed char>(*rax71 + al72);
    *rax73 = reinterpret_cast<signed char>(*rax74 + al75);
    *rax76 = reinterpret_cast<signed char>(*rax77 + al78);
    *rax79 = reinterpret_cast<signed char>(*rax80 + al81);
    *rax82 = reinterpret_cast<signed char>(*rax83 + al84);
    *rax85 = reinterpret_cast<signed char>(*rax86 + al87);
    *rax88 = reinterpret_cast<signed char>(*rax89 + al90);
    *rax91 = reinterpret_cast<signed char>(*rax92 + al93);
    *rax94 = reinterpret_cast<signed char>(*rax95 + al96);
    *rax97 = reinterpret_cast<signed char>(*rax98 + al99);
    *rax100 = reinterpret_cast<signed char>(*rax101 + al102);
    *rax103 = reinterpret_cast<signed char>(*rax104 + al105);
    *rax106 = reinterpret_cast<signed char>(*rax107 + al108);
    *rax109 = reinterpret_cast<signed char>(*rax110 + al111);
    *rax112 = reinterpret_cast<signed char>(*rax113 + al114);
    *rax115 = reinterpret_cast<signed char>(*rax116 + al117);
    *rax118 = reinterpret_cast<signed char>(*rax119 + al120);
    *rax121 = reinterpret_cast<signed char>(*rax122 + al123);
    *rax124 = reinterpret_cast<signed char>(*rax125 + al126);
    *rax127 = reinterpret_cast<signed char>(*rax128 + al129);
    *rax130 = reinterpret_cast<signed char>(*rax131 + al132);
    *rax133 = reinterpret_cast<signed char>(*rax134 + al135);
    *rax136 = reinterpret_cast<signed char>(*rax137 + al138);
    *rax139 = reinterpret_cast<signed char>(*rax140 + al141);
    *rax142 = reinterpret_cast<signed char>(*rax143 + al144);
    *rax145 = reinterpret_cast<signed char>(*rax146 + al147);
    *rax148 = reinterpret_cast<signed char>(*rax149 + al150);
    *rax151 = reinterpret_cast<signed char>(*rax152 + al153);
    *rax154 = reinterpret_cast<signed char>(*rax155 + al156);
    *rax157 = reinterpret_cast<signed char>(*rax158 + al159);
    *rax160 = reinterpret_cast<signed char>(*rax161 + al162);
    *rax163 = reinterpret_cast<signed char>(*rax164 + al165);
    *rax166 = reinterpret_cast<signed char>(*rax167 + al168);
    *rax169 = reinterpret_cast<signed char>(*rax170 + al171);
    *rax172 = reinterpret_cast<signed char>(*rax173 + al174);
    *rax175 = reinterpret_cast<signed char>(*rax176 + al177);
    *rax178 = reinterpret_cast<signed char>(*rax179 + al180);
    *rax181 = reinterpret_cast<signed char>(*rax182 + al183);
    *rax184 = reinterpret_cast<signed char>(*rax185 + al186);
    *rax187 = reinterpret_cast<signed char>(*rax188 + al189);
    *rax190 = reinterpret_cast<signed char>(*rax191 + al192);
    *rax193 = reinterpret_cast<signed char>(*rax194 + al195);
    *rax196 = reinterpret_cast<signed char>(*rax197 + al198);
    *rax199 = reinterpret_cast<signed char>(*rax200 + al201);
    *rax202 = reinterpret_cast<signed char>(*rax203 + al204);
    *rax205 = reinterpret_cast<signed char>(*rax206 + al207);
    *rax208 = reinterpret_cast<signed char>(*rax209 + al210);
    *rax211 = reinterpret_cast<signed char>(*rax212 + al213);
    *rax214 = reinterpret_cast<signed char>(*rax215 + al216);
    *rax217 = reinterpret_cast<signed char>(*rax218 + al219);
    *rax220 = reinterpret_cast<signed char>(*rax221 + al222);
    *rax223 = reinterpret_cast<signed char>(*rax224 + al225);
    *rax226 = reinterpret_cast<signed char>(*rax227 + al228);
    *rax229 = reinterpret_cast<signed char>(*rax230 + al231);
    *rax232 = reinterpret_cast<signed char>(*rax233 + al234);
    *rax235 = reinterpret_cast<signed char>(*rax236 + al237);
    *rax238 = reinterpret_cast<signed char>(*rax239 + al240);
    *rax241 = reinterpret_cast<signed char>(*rax242 + al243);
    *rax244 = reinterpret_cast<signed char>(*rax245 + al246);
    *rax247 = reinterpret_cast<signed char>(*rax248 + al249);
    *rax250 = reinterpret_cast<signed char>(*rax251 + al252);
    *rax253 = reinterpret_cast<signed char>(*rax254 + al255);
    *rax256 = reinterpret_cast<signed char>(*rax257 + al258);
    *rax259 = reinterpret_cast<signed char>(*rax260 + al261);
    *rax262 = reinterpret_cast<signed char>(*rax263 + al264);
    *rax265 = reinterpret_cast<signed char>(*rax266 + al267);
    *rax268 = reinterpret_cast<signed char>(*rax269 + al270);
    *rax271 = reinterpret_cast<signed char>(*rax272 + al273);
    *rax274 = reinterpret_cast<signed char>(*rax275 + al276);
    *rax277 = reinterpret_cast<signed char>(*rax278 + al279);
    *rax280 = reinterpret_cast<signed char>(*rax281 + al282);
    *rax283 = reinterpret_cast<signed char>(*rax284 + al285);
    *rax286 = reinterpret_cast<signed char>(*rax287 + al288);
    *rax289 = reinterpret_cast<signed char>(*rax290 + al291);
    *rax292 = reinterpret_cast<signed char>(*rax293 + al294);
    *rax295 = reinterpret_cast<signed char>(*rax296 + al297);
}