encrypt decompiled /w BinaryNinja

int64_t _init()
{
    call_gmon_start();
    frame_dummy();
    return __do_global_ctors_aux();
}

int64_t sub_400968()
{
    int64_t var_8 = data_6091e8;
    /* jump -> data_6091f0 */
}

int32_t printf(char const* format, ...)
{
    /* tailcall */
    return printf();
}

int64_t sub_40097e()
{
    int64_t var_8 = 0;
    /* tailcall */
    return sub_400968();
}

int64_t memset(void* arg1, int32_t arg2, uint64_t arg3)
{
    /* tailcall */
    return memset(arg1, arg2, arg3);
}

int64_t sub_40098e()
{
    int64_t var_8 = 1;
    /* tailcall */
    return sub_400968();
}

int32_t close(int32_t fd)
{
    /* tailcall */
    return close(fd);
}

int64_t sub_40099e()
{
    int64_t var_8 = 2;
    /* tailcall */
    return sub_400968();
}

int32_t puts(char const* str)
{
    /* tailcall */
    return puts(str);
}

int64_t sub_4009ae()
{
    int64_t var_8 = 3;
    /* tailcall */
    return sub_400968();
}

void exit(int32_t status) __noreturn
{
    /* tailcall */
    return exit(status);
}

int64_t sub_4009be()
{
    int64_t var_8 = 4;
    /* tailcall */
    return sub_400968();
}

int32_t putchar(int32_t c)
{
    /* tailcall */
    return putchar(c);
}

int64_t sub_4009ce()
{
    int64_t var_8 = 5;
    /* tailcall */
    return sub_400968();
}

ssize_t read(int32_t fd, void* buf, uint64_t nbytes)
{
    /* tailcall */
    return read(fd, buf, nbytes);
}

int64_t sub_4009de()
{
    int64_t var_8 = 6;
    /* tailcall */
    return sub_400968();
}

int64_t malloc(uint64_t bytes)
{
    /* tailcall */
    return malloc(bytes);
}

int64_t sub_4009ee()
{
    int64_t var_8 = 7;
    /* tailcall */
    return sub_400968();
}

void __libc_start_main(
    int32_t (* main)(int32_t argc, char** argv, char** envp), int32_t argc,
    char** ubp_av, void (* init)(), void (* fini)(), void (* rtld_fini)(),
    void* stack_end) __noreturn
{
    /* tailcall */
    return __libc_start_main(main, argc, ubp_av, init, fini, rtld_fini, __return_addr);
}

int64_t sub_4009fe()
{
    int64_t var_8 = 8;
    /* tailcall */
    return sub_400968();
}

void free(void* mem)
{
    /* tailcall */
    return free(mem);
}

int64_t sub_400a0e()
{
    int64_t var_8 = 9;
    /* tailcall */
    return sub_400968();
}

int32_t sprintf(char* s, char const* format, ...)
{
    /* tailcall */
    return sprintf();
}

int64_t sub_400a1e()
{
    int64_t var_8 = 0xa;
    /* tailcall */
    return sub_400968();
}

off64_t lseek(int32_t fd, int64_t __arg2, int32_t whence)
{
    /* tailcall */
    return lseek(fd, __arg2, whence);
}

int64_t sub_400a2e()
{
    int64_t var_8 = 0xb;
    /* tailcall */
    return sub_400968();
}

int32_t atoi(char const* nptr)
{
    /* tailcall */
    return atoi(nptr);
}

int64_t sub_400a3e()
{
    int64_t var_8 = 0xc;
    /* tailcall */
    return sub_400968();
}

int64_t memcpy(void* arg1, void const* arg2, uint64_t arg3)
{
    /* tailcall */
    return memcpy(arg1, arg2, arg3);
}

int64_t sub_400a4e()
{
    int64_t var_8 = 0xd;
    /* tailcall */
    return sub_400968();
}

int32_t* __errno_location()
{
    /* tailcall */
    return __errno_location();
}

int64_t sub_400a5e()
{
    int64_t var_8 = 0xe;
    /* tailcall */
    return sub_400968();
}

void __stack_chk_fail() __noreturn
{
    /* tailcall */
    return __stack_chk_fail();
}

int64_t sub_400a6e()
{
    int64_t var_8 = 0xf;
    /* tailcall */
    return sub_400968();
}

int64_t calloc(uint64_t n, uint64_t elem_size)
{
    /* tailcall */
    return calloc(n, elem_size);
}

int64_t sub_400a7e()
{
    int64_t var_8 = 0x10;
    /* tailcall */
    return sub_400968();
}

int64_t dlopen()
{
    /* tailcall */
    return dlopen();
}

int64_t sub_400a8e()
{
    int64_t var_8 = 0x11;
    /* tailcall */
    return sub_400968();
}

int64_t dlsym()
{
    /* tailcall */
    return dlsym();
}

int64_t sub_400a9e()
{
    int64_t var_8 = 0x12;
    /* tailcall */
    return sub_400968();
}

int32_t fprintf(FILE* stream, char const* format, ...)
{
    /* tailcall */
    return fprintf();
}

int64_t sub_400aae()
{
    int64_t var_8 = 0x13;
    /* tailcall */
    return sub_400968();
}

ssize_t write(int32_t fd, void const* buf, uint64_t nbytes)
{
    /* tailcall */
    return write(fd, buf, nbytes);
}

int64_t sub_400abe()
{
    int64_t var_8 = 0x14;
    /* tailcall */
    return sub_400968();
}

int32_t open(char const* file, int32_t oflag, ...)
{
    /* tailcall */
    return open();
}

int64_t sub_400ace()
{
    int64_t var_8 = 0x15;
    /* tailcall */
    return sub_400968();
}

int64_t _start(int64_t arg1, int64_t arg2, void (* arg3)()) __noreturn
{
    int64_t rax;
    int64_t var_8 = rax;
    __libc_start_main(main, __return_addr, &arg_8, __libc_csu_init, __libc_csu_fini, arg3, &var_8);
    /* no return */
}

void call_gmon_start()
{
    if (__gmon_start__ != 0)
    {
        __gmon_start__();
    }
}

void __do_global_dtors_aux()
{
    if (completed.6183 == 0)
    {
        while (true)
        {
            int64_t* rax = p.6181;
            int64_t rdx_1 = *rax;
            if (rdx_1 == 0)
            {
                break;
            }
            p.6181 = &rax[1];
            rdx_1();
        }
        completed.6183 = 1;
    }
}

void frame_dummy()
{
    return;
}

uint64_t init_libssl()
{
    void* fsbase;
    int64_t rax = *(fsbase + 0x28);
    plibssl = dlopen("libssl.so", 2);
    int32_t var_4c;
    if (plibssl == 0)
    {
        for (int32_t var_3c_1 = 0; var_3c_1 <= 0xf; var_3c_1 = (var_3c_1 + 1))
        {
            void var_38;
            sprintf(&var_38, "libssl.so.%d", var_3c_1);
            plibssl = dlopen(&var_38, 2);
            if (plibssl != 0)
            {
                break;
            }
        }
        var_4c = 1;
    }
    lBIO_new_mem_buf = dlsym(plibssl, "BIO_new_mem_buf");
    if (lBIO_new_mem_buf == 0)
    {
        var_4c = 2;
    }
    else
    {
        lERR_get_error = dlsym(plibssl, "ERR_get_error");
        if (lERR_get_error == 0)
        {
            var_4c = 3;
        }
        else
        {
            lERR_error_string = dlsym(plibssl, "ERR_error_string");
            if (lERR_error_string == 0)
            {
                var_4c = 4;
            }
            else
            {
                lPEM_read_bio_RSA_PUBKEY = dlsym(plibssl, "PEM_read_bio_RSA_PUBKEY");
                if (lPEM_read_bio_RSA_PUBKEY == 0)
                {
                    var_4c = 5;
                }
                else
                {
                    lPEM_read_bio_RSAPrivateKey = dlsym(plibssl, "PEM_read_bio_RSAPrivateKey");
                    if (lPEM_read_bio_RSAPrivateKey == 0)
                    {
                        var_4c = 6;
                    }
                    else
                    {
                        lRAND_pseudo_bytes = dlsym(plibssl, "RAND_pseudo_bytes");
                        if (lRAND_pseudo_bytes == 0)
                        {
                            var_4c = 7;
                        }
                        else
                        {
                            lRSA_public_encrypt = dlsym(plibssl, "RSA_public_encrypt");
                            if (lRSA_public_encrypt == 0)
                            {
                                var_4c = 8;
                            }
                            else
                            {
                                lRSA_private_decrypt = dlsym(plibssl, "RSA_private_decrypt");
                                if (lRSA_private_decrypt == 0)
                                {
                                    var_4c = 9;
                                }
                                else
                                {
                                    lRSA_size = dlsym(plibssl, "RSA_size");
                                    if (lRSA_size != 0)
                                    {
                                        var_4c = 0;
                                    }
                                    else
                                    {
                                        var_4c = 0xa;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    uint64_t rax_26 = var_4c;
    if ((rax ^ *(fsbase + 0x28)) == 0)
    {
        return rax_26;
    }
    __stack_chk_fail();
    /* no return */
}

int64_t print_error(int64_t arg1, int32_t arg2)
{
    int64_t rax_2;
    if (arg2 == 0)
    {
        rax_2 = printf("[ %s ] - FAIL\n", arg1);
    }
    else
    {
        rax_2 = printf("[ %s ] - FAIL { Errno: %d }\n", arg1, *__errno_location());
    }
    return rax_2;
}

int64_t print_error_ex(int64_t arg1, int32_t arg2)
{
    void* fsbase;
    int64_t rax = *(fsbase + 0x28);
    if (arg2 == 0)
    {
        printf("[ %s ] - FAIL\n", arg1);
    }
    else
    {
        void var_98;
        lERR_error_string(lERR_get_error(), &var_98);
        printf("[ %s ] - FAIL { %s }\n", arg1, &var_98);
    }
    int64_t rax_8 = (rax ^ *(fsbase + 0x28));
    if (rax_8 == 0)
    {
        return rax_8;
    }
    __stack_chk_fail();
    /* no return */
}

uint64_t open_read(char* arg1)
{
    int32_t rax_1 = open(arg1, 0);
    if (rax_1 == 0xffffffff)
    {
        print_error("open", 1);
    }
    return rax_1;
}

uint64_t open_write(char* arg1)
{
    int32_t rax_1 = open(arg1, 0x242, 0x180);
    if (rax_1 == 0xffffffff)
    {
        print_error("open", 1);
    }
    return rax_1;
}

uint64_t open_read_write(char* arg1)
{
    int32_t rax_1 = open(arg1, 2, 0x180);
    if (rax_1 == 0xffffffff)
    {
        print_error("open", 1);
    }
    return rax_1;
}

uint64_t get_file_curr_size(int32_t arg1, off64_t* arg2)
{
    off64_t rax = lseek(arg1, 0, 2);
    int32_t var_2c;
    if (rax != -1)
    {
        *arg2 = rax;
        var_2c = 0;
    }
    else
    {
        print_error("lseek [end]", 1);
        var_2c = 1;
    }
    return var_2c;
}

uint64_t get_pk_data(char* arg1, int64_t* arg2)
{
    int32_t rax = open_read(arg1);
    int32_t var_3c;
    if (rax == 0xffffffff)
    {
        print_error("open_pk_file", 0);
        var_3c = 1;
    }
    else
    {
        off64_t rax_1 = lseek(rax, 0, 2);
        if (rax_1 == -1)
        {
            print_error("lseek [end]", 1);
            var_3c = 2;
        }
        else if (rax_1 == 0)
        {
            puts("get_pk_data: key file is empty!");
            var_3c = 3;
        }
        else
        {
            *arg2 = calloc((rax_1 + 1), 1);
            if (lseek(rax, 0, 0) == -1)
            {
                print_error("lseek [start]", 1);
                var_3c = 4;
            }
            else if (read(rax, *arg2, rax_1) != -1)
            {
                close(rax);
                var_3c = 0;
            }
            else
            {
                print_error("read", 1);
                var_3c = 5;
            }
        }
    }
    return var_3c;
}

uint64_t create_rsa_obj(int64_t arg1, int64_t* arg2)
{
    int64_t rax_1 = lBIO_new_mem_buf(arg1, 0xffffffff);
    int32_t var_2c;
    if (rax_1 == 0)
    {
        print_error_ex("BIO_new_mem_buf", 1);
        var_2c = 1;
    }
    else
    {
        *arg2 = 0;
        if (lPEM_read_bio_RSA_PUBKEY(rax_1, arg2, 0, 0) != 0)
        {
            var_2c = 0;
        }
        else
        {
            print_error_ex("PEM_read_bio_RSA_PUBKEY", 1);
            var_2c = 2;
        }
    }
    return var_2c;
}

uint64_t gen_stream_key(int64_t arg1, int32_t arg2)
{
    int32_t var_18;
    if (lRAND_pseudo_bytes(arg1, arg2) != 0)
    {
        var_18 = 0;
    }
    else
    {
        print_error_ex("RAND_pseudo_bytes", 1);
        var_18 = 1;
    }
    return var_18;
}

uint64_t rsa_encrypt(int64_t arg1, int64_t arg2, int32_t arg3, int64_t* arg4,
    int32_t* arg5)
{
    int32_t var_44;
    if (lRSA_size(arg1) <= arg3)
    {
        puts("encrypt_bytes: too big data");
        var_44 = 1;
    }
    else
    {
        *arg4 = calloc(lRSA_size(arg1), 1);
        int32_t rax_7 = lRSA_public_encrypt(arg3, arg2, *arg4, arg1, 1);
        if (rax_7 != 0xffffffff)
        {
            *arg5 = rax_7;
            var_44 = 0;
        }
        else
        {
            print_error_ex("RSA_public_encrypt", 1);
            var_44 = 2;
        }
    }
    return var_44;
}

uint64_t dump_data(char* arg1, int64_t arg2, int32_t arg3)
{
    int32_t rax = open_write(arg1);
    int32_t var_30;
    if (rax == 0xffffffff)
    {
        print_error("open_write", 0);
        var_30 = 1;
    }
    else if (write(rax, arg2, arg3) != -1)
    {
        close(rax);
        var_30 = 0;
    }
    else
    {
        print_error("write", 1);
        var_30 = 2;
    }
    return var_30;
}

uint64_t encrypt_simple(int32_t arg1, int64_t arg2, int64_t arg3, int64_t arg4,
    int32_t arg5, int64_t arg6)
{
    void* fsbase;
    int64_t rax = *(fsbase + 0x28);
    void var_278;
    sosemanuk_schedule(&var_278, arg4, arg5);
    void var_a8;
    sosemanuk_init(&var_a8, &var_278, 0, 0);
    int32_t var_2cc;
    int64_t var_c0;
    if (get_file_curr_size(arg1, &var_c0) != 0)
    {
        print_error("fstat", 1);
        var_2cc = 1;
    }
    else
    {
        if (arg6 < var_c0)
        {
            var_c0 = arg6;
        }
        if (var_c0 == 0)
        {
            var_2cc = 0;
        }
        else
        {
            char* rax_6 = malloc(0x100000);
            if (rax_6 == 0)
            {
                print_error("malloc", 1);
                var_2cc = 2;
            }
            else if (lseek(arg1, 0, 0) == -1)
            {
                print_error("lseek [start]", 1);
                var_2cc = 0xa;
            }
            else
            {
                int64_t var_290_1 = (arg3 << 0x14);
                int64_t var_288_1 = (arg2 << 0x14);
                int64_t var_d0_1 = 0;
                int64_t var_b8_1 = 0;
                while (true)
                {
                    int64_t var_d8_1 = 0;
                    uint64_t var_e8_1;
                    int64_t var_b8_2;
                    while (true)
                    {
                        if (var_d8_1 < var_290_1)
                        {
                            var_e8_1 = read(arg1, rax_6, 0x100000);
                            if (var_e8_1 == -1)
                            {
                                print_error("fstat", 1);
                                var_2cc = 3;
                                break;
                            }
                            sosemanuk_encrypt(&var_a8, rax_6, rax_6, var_e8_1);
                            if (lseek(arg1, (-var_e8_1), 1) == -1)
                            {
                                print_error("lseek", 1);
                                var_2cc = 4;
                                break;
                            }
                            if (write(arg1, rax_6, var_e8_1) == -1)
                            {
                                print_error("write", 1);
                                var_2cc = 5;
                                break;
                            }
                            var_d8_1 = (var_d8_1 + var_e8_1);
                            if (var_e8_1 > 0xfffff)
                            {
                                continue;
                            }
                        }
                        var_b8_2 = (var_b8_1 + var_d8_1);
                        break;
                    }
                    if ((var_d8_1 < var_290_1 && var_e8_1 == -1))
                    {
                        break;
                    }
                    if ((var_288_1 + var_b8_2) < var_c0)
                    {
                        if (lseek(arg1, var_288_1, 1) == -1)
                        {
                            print_error("lseek", 1);
                            var_2cc = 6;
                            break;
                        }
                        var_b8_1 = (var_b8_2 + var_288_1);
                        int32_t var_2dc_1 = 0x66666666;
                        int64_t rax_21;
                        int64_t rdx_5;
                        rdx_5 = HIGHD((0x66666667 * var_d0_1));
                        rax_21 = LOWD((0x66666667 * var_d0_1));
                        int64_t rax_26 = (((rdx_5 >> 2) - (var_d0_1 >> 0x3f)) * 5);
                        if ((var_d0_1 - (rax_26 + rax_26)) == 0)
                        {
                            double var_2c0_1;
                            double zmm0;
                            if (var_b8_1 < 0)
                            {
                                zmm0 = ((var_b8_1 >> 1) | (var_b8_1 & 1));
                                var_2c0_1 = (zmm0 + zmm0);
                            }
                            else
                            {
                                var_2c0_1 = var_b8_1;
                            }
                            double var_e0_1 = (100.0 * var_2c0_1);
                            int64_t rax_31 = var_c0;
                            double var_2b0_1;
                            if (rax_31 < 0)
                            {
                                zmm0 = ((rax_31 >> 1) | (rax_31 & 1));
                                var_2b0_1 = (zmm0 + zmm0);
                            }
                            else
                            {
                                var_2b0_1 = rax_31;
                            }
                            zmm0 = (var_e0_1 / var_2b0_1);
                            if (((!(zmm0 == 100.0 | (FCMP_UO(zmm0, 100.0)))) && (!(zmm0 < 100.0 | (FCMP_UO(zmm0, 100.0))))))
                            {
                                double var_e0_2 = 100.0;
                            }
                            if (var_d0_1 != 0)
                            {
                                putchar(0xd);
                            }
                            printf("Progress: %f");
                        }
                        var_d0_1 = (var_d0_1 + 1);
                        if (var_b8_1 < var_c0)
                        {
                            continue;
                        }
                    }
                    putchar(0xa);
                    free(rax_6);
                    var_2cc = 0;
                    break;
                }
            }
        }
    }
    uint64_t rax_37 = var_2cc;
    if ((rax ^ *(fsbase + 0x28)) == 0)
    {
        return rax_37;
    }
    __stack_chk_fail();
    /* no return */
}

uint64_t encrypt_file(char* arg1, int64_t arg2, int64_t arg3, int64_t arg4,
    int64_t arg5)
{
    void* fsbase;
    int64_t rax = *(fsbase + 0x28);
    int32_t rax_2 = open_read_write(arg1);
    int32_t var_74;
    void var_38;
    if (rax_2 == 0xffffffff)
    {
        print_error("open_read", 1);
        var_74 = 1;
    }
    else
    {
        int64_t var_48;
        int32_t var_40;
        if (gen_stream_key(&var_38, 0x20) != 0)
        {
            print_error("get_pk_data", 0);
            var_74 = 2;
        }
        else if (rsa_encrypt(arg2, &var_38, 0x20, &var_48, &var_40) != 0)
        {
            print_error("rsa_encrypt", 0);
            var_74 = 3;
        }
        else if (encrypt_simple(rax_2, arg3, arg4, &var_38, 0x20, arg5) != 0)
        {
            print_error("encrypt_simple", 0);
            var_74 = 4;
        }
        else if (lseek(rax_2, 0, 2) == -1)
        {
            print_error("lseek", 1);
            var_74 = 5;
        }
        else if (write(rax_2, var_48, var_40) != -1)
        {
            var_74 = 0;
        }
        else
        {
            print_error("write", 1);
            var_74 = 6;
        }
    }
    uint64_t rax_10 = var_74;
    if ((rax ^ *(fsbase + 0x28)) == 0)
    {
        return rax_10;
    }
    __stack_chk_fail();
    /* no return */
}

int32_t main(int32_t argc, char** argv, char** envp)
{
    int32_t var_4c;
    if (argc <= 2)
    {
        puts("usage: encrypt <public_key> <fil…");
        puts("       enc_step   -   number of …");
        puts("       enc_size   -   number of …");
        puts("       file_size  -   file size …");
        var_4c = 1;
    }
    else
    {
        int64_t var_28_1 = 0;
        int64_t var_30_1 = 1;
        int64_t var_38_1 = 0;
        if (argc > 3)
        {
            var_28_1 = atoi(argv[3]);
        }
        if (argc > 4)
        {
            var_30_1 = atoi(argv[4]);
        }
        if (argc > 5)
        {
            var_38_1 = atoi(argv[5]);
        }
        int32_t rax_13 = init_libssl();
        int64_t var_18;
        if (rax_13 != 0)
        {
            printf("init_libssl returned %d\n", rax_13);
            var_4c = 2;
        }
        else
        {
            int64_t var_20;
            if (get_pk_data(argv[1], &var_18) != 0)
            {
                print_error("get_pk_data", 0);
                var_4c = 3;
            }
            else if (create_rsa_obj(var_18, &var_20) != 0)
            {
                print_error("create_rsa_obj", 0);
                var_4c = 4;
            }
            else if (encrypt_file(argv[2], var_20, var_28_1, var_30_1, var_38_1) == 0)
            {
                var_4c = 0;
            }
            else
            {
                print_error("encrypt_file", 0);
                var_4c = 5;
            }
        }
    }
    return var_4c;
}

int64_t sosemanuk_schedule(void* arg1, int64_t arg2, uint64_t arg3)
{
    void* fsbase;
    int64_t rax = *(fsbase + 0x28);
    int32_t var_3c = 0;
    if ((arg3 != 0 && arg3 <= 0x20))
    {
        void var_38;
        memcpy(&var_38, arg2, arg3);
        if (arg3 <= 0x1f)
        {
            *(&var_38 + arg3) = 1;
            if (arg3 <= 0x1e)
            {
                memset(((&var_38 + arg3) + 1), 0, (0x1f - arg3));
            }
        }
        int32_t rax_5 = decode32le(&var_38);
        void var_34;
        int32_t rax_6 = decode32le(&var_34);
        void var_30;
        int32_t rax_7 = decode32le(&var_30);
        void var_2c;
        int32_t rax_8 = decode32le(&var_2c);
        void var_28;
        int32_t rax_9 = decode32le(&var_28);
        void var_24;
        int32_t rax_10 = decode32le(&var_24);
        void var_20;
        int32_t rax_11 = decode32le(&var_20);
        void var_1c;
        int32_t rax_12 = decode32le(&var_1c);
        int32_t rdx_5 = (RORD(((((rax_5 ^ rax_8) ^ rax_10) ^ rax_12) ^ 0x9e3779b9), 0x15));
        int32_t rdx_7 = (RORD(((((rax_6 ^ rax_9) ^ rax_11) ^ rdx_5) ^ 0x9e3779b8), 0x15));
        int32_t rdx_9 = (RORD(((((rax_7 ^ rax_10) ^ rax_12) ^ rdx_7) ^ 0x9e3779bb), 0x15));
        int32_t rdx_11 = (RORD(((((rax_8 ^ rax_11) ^ rdx_5) ^ rdx_9) ^ 0x9e3779ba), 0x15));
        int32_t var_50_1 = (rdx_5 | rdx_11);
        int32_t var_5c_1 = (rdx_11 ^ rdx_7);
        int32_t var_54_1 = (rdx_7 & rdx_5);
        int32_t var_58_1 = (rdx_9 ^ var_5c_1);
        int32_t var_60_2 = ((rdx_5 ^ rdx_9) | var_54_1);
        int32_t var_5c_3 = ((var_5c_1 & var_50_1) ^ var_60_2);
        int32_t var_50_2 = (var_50_1 ^ var_54_1);
        int32_t var_54_4 = (((var_54_1 ^ var_5c_3) | var_50_2) ^ var_58_1);
        *arg1 = ((var_54_4 | var_5c_3) ^ (var_50_2 ^ var_5c_3));
        int32_t var_3c_1 = 1;
        *(arg1 + 4) = var_54_4;
        int32_t var_3c_2 = 2;
        *(arg1 + 8) = var_5c_3;
        int32_t var_3c_3 = 3;
        *(arg1 + 0xc) = ((var_60_2 & var_50_2) ^ var_58_1);
        int32_t var_3c_4 = 4;
        int32_t rdx_15 = (RORD(((((rax_9 ^ rax_12) ^ rdx_7) ^ rdx_11) ^ 0x9e3779bd), 0x15));
        int32_t rdx_17 = (RORD(((((rax_10 ^ rdx_5) ^ rdx_9) ^ rdx_15) ^ 0x9e3779bc), 0x15));
        int32_t rdx_19 = (RORD(((((rax_11 ^ rdx_7) ^ rdx_11) ^ rdx_17) ^ 0x9e3779bf), 0x15));
        int32_t rdx_21 = (RORD(((((rax_12 ^ rdx_9) ^ rdx_15) ^ rdx_19) ^ 0x9e3779be), 0x15));
        int32_t var_74_2 = ((rdx_15 & rdx_19) ^ rdx_21);
        int32_t var_7c_2 = ((rdx_19 ^ rdx_17) ^ var_74_2);
        int32_t var_80_2 = ((rdx_21 | rdx_15) ^ rdx_17);
        int32_t var_84_1 = (rdx_15 ^ var_7c_2);
        int32_t var_80_4 = ((var_80_2 | var_84_1) ^ var_74_2);
        int32_t var_84_2 = (var_84_1 ^ (var_74_2 & var_80_2));
        *(arg1 + 0x10) = var_7c_2;
        int32_t var_3c_5 = 5;
        *(arg1 + 0x14) = var_80_4;
        int32_t var_3c_6 = 6;
        *(arg1 + 0x18) = ((var_80_2 ^ var_80_4) ^ var_84_2);
        int32_t var_3c_7 = 7;
        *(arg1 + 0x1c) = (!var_84_2);
        int32_t var_3c_8 = 8;
        int32_t rdx_25 = (RORD(((((rdx_5 ^ rdx_11) ^ rdx_17) ^ rdx_21) ^ 0x9e3779b1), 0x15));
        int32_t rdx_27 = (RORD(((((rdx_7 ^ rdx_15) ^ rdx_19) ^ rdx_25) ^ 0x9e3779b0), 0x15));
        int32_t rdx_29 = (RORD(((((rdx_9 ^ rdx_17) ^ rdx_21) ^ rdx_27) ^ 0x9e3779b3), 0x15));
        int32_t rdx_31 = (RORD(((((rdx_11 ^ rdx_19) ^ rdx_25) ^ rdx_29) ^ 0x9e3779b2), 0x15));
        int32_t var_98_1 = (!rdx_25);
        int32_t var_98_2 = (var_98_1 & rdx_27);
        int32_t var_a0_2 = ((!rdx_29) ^ var_98_2);
        int32_t var_98_3 = (var_98_2 | rdx_31);
        int32_t var_a4_1 = (rdx_31 ^ var_a0_2);
        int32_t var_9c_1 = (rdx_27 ^ var_98_3);
        int32_t var_98_4 = (var_98_3 ^ var_98_1);
        int32_t var_a8_1 = (var_98_1 | var_9c_1);
        int32_t var_9c_2 = (var_9c_1 ^ var_a4_1);
        int32_t var_a0_4 = ((var_a0_2 | var_98_4) & var_a8_1);
        int32_t var_98_5 = (var_98_4 ^ var_9c_2);
        *(arg1 + 0x20) = var_a0_4;
        int32_t var_3c_9 = 9;
        *(arg1 + 0x24) = ((var_98_5 & var_a0_4) ^ var_a8_1);
        int32_t var_3c_10 = 0xa;
        *(arg1 + 0x28) = var_a4_1;
        int32_t var_3c_11 = 0xb;
        *(arg1 + 0x2c) = ((var_9c_2 & var_a0_4) ^ var_98_5);
        int32_t var_3c_12 = 0xc;
        int32_t rdx_35 = (RORD(((((rdx_15 ^ rdx_21) ^ rdx_27) ^ rdx_31) ^ 0x9e3779b5), 0x15));
        int32_t rdx_37 = (RORD(((((rdx_17 ^ rdx_25) ^ rdx_29) ^ rdx_35) ^ 0x9e3779b4), 0x15));
        int32_t rdx_39 = (RORD(((((rdx_19 ^ rdx_27) ^ rdx_31) ^ rdx_37) ^ 0x9e3779b7), 0x15));
        int32_t rdx_41 = (RORD(((((rdx_21 ^ rdx_29) ^ rdx_35) ^ rdx_39) ^ 0x9e3779b6), 0x15));
        int32_t var_c8_1 = (rdx_41 ^ rdx_35);
        int32_t var_cc_1 = (rdx_37 ^ rdx_39);
        int32_t var_c0_2 = ((rdx_37 & var_c8_1) ^ rdx_35);
        int32_t var_bc_2 = ((rdx_35 | var_c8_1) ^ var_cc_1);
        int32_t var_cc_2 = (var_cc_1 ^ var_c8_1);
        int32_t var_c8_2 = (var_c8_1 ^ rdx_39);
        int32_t var_cc_4 = ((!var_cc_2) | var_c0_2);
        int32_t var_c8_3 = (var_c8_2 | var_bc_2);
        *(arg1 + 0x30) = (((var_c0_2 ^ var_c8_2) ^ var_cc_4) ^ var_c8_3);
        int32_t var_3c_13 = 0xd;
        *(arg1 + 0x34) = (var_cc_4 ^ var_c8_3);
        int32_t var_3c_14 = 0xe;
        *(arg1 + 0x38) = ((rdx_39 | var_c0_2) ^ var_cc_2);
        int32_t var_3c_15 = 0xf;
        *(arg1 + 0x3c) = var_bc_2;
        int32_t var_3c_16 = 0x10;
        int32_t rdx_45 = (RORD(((((rdx_25 ^ rdx_31) ^ rdx_37) ^ rdx_41) ^ 0x9e3779a9), 0x15));
        int32_t rdx_47 = (RORD(((((rdx_27 ^ rdx_35) ^ rdx_39) ^ rdx_45) ^ 0x9e3779a8), 0x15));
        int32_t rdx_49 = (RORD(((((rdx_29 ^ rdx_37) ^ rdx_41) ^ rdx_47) ^ 0x9e3779ab), 0x15));
        int32_t rdx_51 = (RORD(((((rdx_31 ^ rdx_39) ^ rdx_45) ^ rdx_49) ^ 0x9e3779aa), 0x15));
        int32_t var_e4_2 = ((rdx_47 | rdx_49) ^ rdx_51);
        int32_t var_f0_1 = (rdx_47 ^ rdx_49);
        int32_t var_e8_1 = (rdx_49 ^ var_e4_2);
        int32_t var_f0_2 = (var_f0_1 ^ var_e8_1);
        int32_t var_e0_2 = ((rdx_45 | var_f0_2) ^ var_e8_1);
        int32_t var_e4_5 = (((var_e4_2 | var_f0_2) ^ rdx_45) ^ var_f0_2);
        *(arg1 + 0x40) = (var_f0_2 ^ ((!(var_e8_1 ^ var_e4_5)) | var_e0_2));
        int32_t var_3c_17 = 0x11;
        *(arg1 + 0x44) = (((rdx_51 | var_f0_1) & rdx_45) ^ var_e4_2);
        int32_t var_3c_18 = 0x12;
        *(arg1 + 0x48) = ((var_e4_5 & var_e0_2) ^ var_f0_2);
        int32_t var_3c_19 = 0x13;
        *(arg1 + 0x4c) = var_e0_2;
        int32_t var_3c_20 = 0x14;
        int32_t rdx_55 = (RORD(((((rdx_35 ^ rdx_41) ^ rdx_47) ^ rdx_51) ^ 0x9e3779ad), 0x15));
        int32_t rdx_57 = (RORD(((((rdx_37 ^ rdx_45) ^ rdx_49) ^ rdx_55) ^ 0x9e3779ac), 0x15));
        int32_t rdx_59 = (RORD(((((rdx_39 ^ rdx_47) ^ rdx_51) ^ rdx_57) ^ 0x9e3779af), 0x15));
        int32_t rdx_61 = (RORD(((((rdx_41 ^ rdx_49) ^ rdx_55) ^ rdx_59) ^ 0x9e3779ae), 0x15));
        int32_t var_10c_1 = (!rdx_59);
        int32_t var_104_1 = (rdx_55 ^ rdx_61);
        int32_t var_110_2 = ((rdx_61 & rdx_55) ^ var_10c_1);
        int32_t var_108_1 = (rdx_57 ^ var_110_2);
        int32_t var_104_2 = (var_104_1 | var_108_1);
        int32_t var_10c_4 = (((var_10c_1 | rdx_61) ^ var_104_1) ^ var_108_1);
        int32_t var_104_4 = ((var_104_2 | var_110_2) ^ var_10c_4);
        int32_t var_114_3 = (((rdx_61 ^ var_104_2) ^ var_110_2) ^ var_104_4);
        *(arg1 + 0x50) = var_104_4;
        int32_t var_3c_21 = 0x15;
        *(arg1 + 0x54) = var_108_1;
        int32_t var_3c_22 = 0x16;
        *(arg1 + 0x58) = var_114_3;
        int32_t var_3c_23 = 0x17;
        *(arg1 + 0x5c) = ((var_10c_4 & var_114_3) ^ (!var_110_2));
        int32_t var_3c_24 = 0x18;
        int32_t rdx_65 = (RORD(((((rdx_45 ^ rdx_51) ^ rdx_57) ^ rdx_61) ^ 0x9e3779a1), 0x15));
        int32_t rdx_67 = (RORD(((((rdx_47 ^ rdx_55) ^ rdx_59) ^ rdx_65) ^ 0x9e3779a0), 0x15));
        int32_t rdx_69 = (RORD(((((rdx_49 ^ rdx_57) ^ rdx_61) ^ rdx_67) ^ 0x9e3779a3), 0x15));
        int32_t rdx_71 = (RORD(((((rdx_51 ^ rdx_59) ^ rdx_65) ^ rdx_69) ^ 0x9e3779a2), 0x15));
        int32_t var_128_1 = (rdx_65 ^ rdx_67);
        int32_t var_12c_1 = (rdx_67 ^ rdx_71);
        int32_t var_134_1 = (!rdx_71);
        int32_t var_130_1 = (rdx_69 ^ var_134_1);
        int32_t var_12c_3 = ((var_12c_1 & var_128_1) ^ var_130_1);
        int32_t var_130_2 = (var_130_1 | var_12c_1);
        int32_t var_134_3 = ((var_134_1 & var_12c_3) ^ var_128_1);
        int32_t var_138_3 = (((var_12c_1 ^ var_134_1) ^ var_12c_3) ^ var_130_2);
        *(arg1 + 0x60) = var_12c_3;
        int32_t var_3c_25 = 0x19;
        *(arg1 + 0x64) = var_134_3;
        int32_t var_3c_26 = 0x1a;
        *(arg1 + 0x68) = ((var_128_1 & var_134_3) ^ var_138_3);
        int32_t var_3c_27 = 0x1b;
        *(arg1 + 0x6c) = ((!(var_130_2 ^ var_128_1)) ^ (var_138_3 | var_134_3));
        int32_t var_3c_28 = 0x1c;
        int32_t rdx_75 = (RORD(((((rdx_55 ^ rdx_61) ^ rdx_67) ^ rdx_71) ^ 0x9e3779a5), 0x15));
        int32_t rdx_77 = (RORD(((((rdx_57 ^ rdx_65) ^ rdx_69) ^ rdx_75) ^ 0x9e3779a4), 0x15));
        int32_t rdx_79 = (RORD(((((rdx_59 ^ rdx_67) ^ rdx_71) ^ rdx_77) ^ 0x9e3779a7), 0x15));
        int32_t rdx_81 = (RORD(((((rdx_61 ^ rdx_69) ^ rdx_75) ^ rdx_79) ^ 0x9e3779a6), 0x15));
        int32_t var_150_1 = (rdx_77 ^ rdx_81);
        int32_t var_158_1 = (!rdx_81);
        int32_t var_154_1 = (rdx_79 ^ var_158_1);
        int32_t var_158_2 = (var_158_1 ^ rdx_75);
        int32_t var_150_3 = ((var_150_1 & var_158_2) ^ var_154_1);
        int32_t var_15c_1 = (var_150_1 ^ var_158_2);
        int32_t var_14c_1 = (rdx_75 ^ var_15c_1);
        int32_t var_154_3 = ((var_154_1 & var_15c_1) ^ var_14c_1);
        int32_t var_14c_2 = (var_14c_1 & var_150_3);
        int32_t var_158_3 = (var_158_2 ^ var_14c_2);
        *(arg1 + 0x70) = var_150_3;
        int32_t var_3c_29 = 0x1d;
        *(arg1 + 0x74) = (((var_15c_1 | var_150_3) ^ var_14c_2) ^ (var_154_3 & var_158_3));
        int32_t var_3c_30 = 0x1e;
        *(arg1 + 0x78) = (!((var_14c_2 | var_158_3) ^ var_154_3));
        int32_t var_3c_31 = 0x1f;
        *(arg1 + 0x7c) = var_158_3;
        int32_t var_3c_32 = 0x20;
        int32_t rdx_85 = (RORD(((((rdx_65 ^ rdx_71) ^ rdx_77) ^ rdx_81) ^ 0x9e377999), 0x15));
        int32_t rdx_87 = (RORD(((((rdx_67 ^ rdx_75) ^ rdx_79) ^ rdx_85) ^ 0x9e377998), 0x15));
        int32_t rdx_89 = (RORD(((((rdx_69 ^ rdx_77) ^ rdx_81) ^ rdx_87) ^ 0x9e37799b), 0x15));
        int32_t rdx_91 = (RORD(((((rdx_71 ^ rdx_79) ^ rdx_85) ^ rdx_89) ^ 0x9e37799a), 0x15));
        int32_t var_170_1 = (rdx_85 | rdx_91);
        int32_t var_17c_1 = (rdx_91 ^ rdx_87);
        int32_t var_174_1 = (rdx_87 & rdx_85);
        int32_t var_178_1 = (rdx_89 ^ var_17c_1);
        int32_t var_180_2 = ((rdx_85 ^ rdx_89) | var_174_1);
        int32_t var_17c_3 = ((var_17c_1 & var_170_1) ^ var_180_2);
        int32_t var_170_2 = (var_170_1 ^ var_174_1);
        int32_t var_174_4 = (((var_174_1 ^ var_17c_3) | var_170_2) ^ var_178_1);
        *(arg1 + 0x80) = ((var_174_4 | var_17c_3) ^ (var_170_2 ^ var_17c_3));
        int32_t var_3c_33 = 0x21;
        *(arg1 + 0x84) = var_174_4;
        int32_t var_3c_34 = 0x22;
        *(arg1 + 0x88) = var_17c_3;
        int32_t var_3c_35 = 0x23;
        *(arg1 + 0x8c) = ((var_180_2 & var_170_2) ^ var_178_1);
        int32_t var_3c_36 = 0x24;
        int32_t rdx_95 = (RORD(((((rdx_75 ^ rdx_81) ^ rdx_87) ^ rdx_91) ^ 0x9e37799d), 0x15));
        int32_t rdx_97 = (RORD(((((rdx_77 ^ rdx_85) ^ rdx_89) ^ rdx_95) ^ 0x9e37799c), 0x15));
        int32_t rdx_99 = (RORD(((((rdx_79 ^ rdx_87) ^ rdx_91) ^ rdx_97) ^ 0x9e37799f), 0x15));
        int32_t rdx_101 = (RORD(((((rdx_81 ^ rdx_89) ^ rdx_95) ^ rdx_99) ^ 0x9e37799e), 0x15));
        int32_t var_194_2 = ((rdx_95 & rdx_99) ^ rdx_101);
        int32_t var_19c_2 = ((rdx_99 ^ rdx_97) ^ var_194_2);
        int32_t var_1a0_2 = ((rdx_101 | rdx_95) ^ rdx_97);
        int32_t var_1a4_1 = (rdx_95 ^ var_19c_2);
        int32_t var_1a0_4 = ((var_1a0_2 | var_1a4_1) ^ var_194_2);
        int32_t var_1a4_2 = (var_1a4_1 ^ (var_194_2 & var_1a0_2));
        *(arg1 + 0x90) = var_19c_2;
        int32_t var_3c_37 = 0x25;
        *(arg1 + 0x94) = var_1a0_4;
        int32_t var_3c_38 = 0x26;
        *(arg1 + 0x98) = ((var_1a0_2 ^ var_1a0_4) ^ var_1a4_2);
        int32_t var_3c_39 = 0x27;
        *(arg1 + 0x9c) = (!var_1a4_2);
        int32_t var_3c_40 = 0x28;
        int32_t rdx_105 = (RORD(((((rdx_85 ^ rdx_91) ^ rdx_97) ^ rdx_101) ^ 0x9e377991), 0x15));
        int32_t rdx_107 = (RORD(((((rdx_87 ^ rdx_95) ^ rdx_99) ^ rdx_105) ^ 0x9e377990), 0x15));
        int32_t rdx_109 = (RORD(((((rdx_89 ^ rdx_97) ^ rdx_101) ^ rdx_107) ^ 0x9e377993), 0x15));
        int32_t rdx_111 = (RORD(((((rdx_91 ^ rdx_99) ^ rdx_105) ^ rdx_109) ^ 0x9e377992), 0x15));
        int32_t var_1b8_1 = (!rdx_105);
        int32_t var_1b8_2 = (var_1b8_1 & rdx_107);
        int32_t var_1c0_2 = ((!rdx_109) ^ var_1b8_2);
        int32_t var_1b8_3 = (var_1b8_2 | rdx_111);
        int32_t var_1c4_1 = (rdx_111 ^ var_1c0_2);
        int32_t var_1bc_1 = (rdx_107 ^ var_1b8_3);
        int32_t var_1b8_4 = (var_1b8_3 ^ var_1b8_1);
        int32_t var_1c8_1 = (var_1b8_1 | var_1bc_1);
        int32_t var_1bc_2 = (var_1bc_1 ^ var_1c4_1);
        int32_t var_1c0_4 = ((var_1c0_2 | var_1b8_4) & var_1c8_1);
        int32_t var_1b8_5 = (var_1b8_4 ^ var_1bc_2);
        *(arg1 + 0xa0) = var_1c0_4;
        int32_t var_3c_41 = 0x29;
        *(arg1 + 0xa4) = ((var_1b8_5 & var_1c0_4) ^ var_1c8_1);
        int32_t var_3c_42 = 0x2a;
        *(arg1 + 0xa8) = var_1c4_1;
        int32_t var_3c_43 = 0x2b;
        *(arg1 + 0xac) = ((var_1bc_2 & var_1c0_4) ^ var_1b8_5);
        int32_t var_3c_44 = 0x2c;
        int32_t rdx_115 = (RORD(((((rdx_95 ^ rdx_101) ^ rdx_107) ^ rdx_111) ^ 0x9e377995), 0x15));
        int32_t rdx_117 = (RORD(((((rdx_97 ^ rdx_105) ^ rdx_109) ^ rdx_115) ^ 0x9e377994), 0x15));
        int32_t rdx_119 = (RORD(((((rdx_99 ^ rdx_107) ^ rdx_111) ^ rdx_117) ^ 0x9e377997), 0x15));
        int32_t rdx_121 = (RORD(((((rdx_101 ^ rdx_109) ^ rdx_115) ^ rdx_119) ^ 0x9e377996), 0x15));
        int32_t var_1e8_1 = (rdx_121 ^ rdx_115);
        int32_t var_1ec_1 = (rdx_117 ^ rdx_119);
        int32_t var_1e0_2 = ((rdx_117 & var_1e8_1) ^ rdx_115);
        int32_t var_1dc_2 = ((rdx_115 | var_1e8_1) ^ var_1ec_1);
        int32_t var_1ec_2 = (var_1ec_1 ^ var_1e8_1);
        int32_t var_1e8_2 = (var_1e8_1 ^ rdx_119);
        int32_t var_1ec_4 = ((!var_1ec_2) | var_1e0_2);
        int32_t var_1e8_3 = (var_1e8_2 | var_1dc_2);
        *(arg1 + 0xb0) = (((var_1e0_2 ^ var_1e8_2) ^ var_1ec_4) ^ var_1e8_3);
        int32_t var_3c_45 = 0x2d;
        *(arg1 + 0xb4) = (var_1ec_4 ^ var_1e8_3);
        int32_t var_3c_46 = 0x2e;
        *(arg1 + 0xb8) = ((rdx_119 | var_1e0_2) ^ var_1ec_2);
        int32_t var_3c_47 = 0x2f;
        *(arg1 + 0xbc) = var_1dc_2;
        int32_t var_3c_48 = 0x30;
        int32_t rdx_125 = (RORD(((((rdx_105 ^ rdx_111) ^ rdx_117) ^ rdx_121) ^ 0x9e377989), 0x15));
        int32_t rdx_127 = (RORD(((((rdx_107 ^ rdx_115) ^ rdx_119) ^ rdx_125) ^ 0x9e377988), 0x15));
        int32_t rdx_129 = (RORD(((((rdx_109 ^ rdx_117) ^ rdx_121) ^ rdx_127) ^ 0x9e37798b), 0x15));
        int32_t rdx_131 = (RORD(((((rdx_111 ^ rdx_119) ^ rdx_125) ^ rdx_129) ^ 0x9e37798a), 0x15));
        int32_t var_204_2 = ((rdx_127 | rdx_129) ^ rdx_131);
        int32_t var_210_1 = (rdx_127 ^ rdx_129);
        int32_t var_208_1 = (rdx_129 ^ var_204_2);
        int32_t var_210_2 = (var_210_1 ^ var_208_1);
        int32_t var_200_2 = ((rdx_125 | var_210_2) ^ var_208_1);
        int32_t var_204_5 = (((var_204_2 | var_210_2) ^ rdx_125) ^ var_210_2);
        *(arg1 + 0xc0) = (var_210_2 ^ ((!(var_208_1 ^ var_204_5)) | var_200_2));
        int32_t var_3c_49 = 0x31;
        *(arg1 + 0xc4) = (((rdx_131 | var_210_1) & rdx_125) ^ var_204_2);
        int32_t var_3c_50 = 0x32;
        *(arg1 + 0xc8) = ((var_204_5 & var_200_2) ^ var_210_2);
        int32_t var_3c_51 = 0x33;
        *(arg1 + 0xcc) = var_200_2;
        int32_t var_3c_52 = 0x34;
        int32_t rdx_135 = (RORD(((((rdx_115 ^ rdx_121) ^ rdx_127) ^ rdx_131) ^ 0x9e37798d), 0x15));
        int32_t rdx_137 = (RORD(((((rdx_117 ^ rdx_125) ^ rdx_129) ^ rdx_135) ^ 0x9e37798c), 0x15));
        int32_t rdx_139 = (RORD(((((rdx_119 ^ rdx_127) ^ rdx_131) ^ rdx_137) ^ 0x9e37798f), 0x15));
        int32_t rdx_141 = (RORD(((((rdx_121 ^ rdx_129) ^ rdx_135) ^ rdx_139) ^ 0x9e37798e), 0x15));
        int32_t var_22c_1 = (!rdx_139);
        int32_t var_224_1 = (rdx_135 ^ rdx_141);
        int32_t var_230_2 = ((rdx_141 & rdx_135) ^ var_22c_1);
        int32_t var_228_1 = (rdx_137 ^ var_230_2);
        int32_t var_224_2 = (var_224_1 | var_228_1);
        int32_t var_22c_4 = (((var_22c_1 | rdx_141) ^ var_224_1) ^ var_228_1);
        int32_t var_224_4 = ((var_224_2 | var_230_2) ^ var_22c_4);
        int32_t var_234_3 = (((rdx_141 ^ var_224_2) ^ var_230_2) ^ var_224_4);
        *(arg1 + 0xd0) = var_224_4;
        int32_t var_3c_53 = 0x35;
        *(arg1 + 0xd4) = var_228_1;
        int32_t var_3c_54 = 0x36;
        *(arg1 + 0xd8) = var_234_3;
        int32_t var_3c_55 = 0x37;
        *(arg1 + 0xdc) = ((var_22c_4 & var_234_3) ^ (!var_230_2));
        int32_t var_3c_56 = 0x38;
        int32_t rdx_145 = (RORD(((((rdx_125 ^ rdx_131) ^ rdx_137) ^ rdx_141) ^ 0x9e377981), 0x15));
        int32_t rdx_147 = (RORD(((((rdx_127 ^ rdx_135) ^ rdx_139) ^ rdx_145) ^ 0x9e377980), 0x15));
        int32_t rdx_149 = (RORD(((((rdx_129 ^ rdx_137) ^ rdx_141) ^ rdx_147) ^ 0x9e377983), 0x15));
        int32_t rdx_151 = (RORD(((((rdx_131 ^ rdx_139) ^ rdx_145) ^ rdx_149) ^ 0x9e377982), 0x15));
        int32_t var_248_1 = (rdx_145 ^ rdx_147);
        int32_t var_24c_1 = (rdx_147 ^ rdx_151);
        int32_t var_254_1 = (!rdx_151);
        int32_t var_250_1 = (rdx_149 ^ var_254_1);
        int32_t var_24c_3 = ((var_24c_1 & var_248_1) ^ var_250_1);
        int32_t var_250_2 = (var_250_1 | var_24c_1);
        int32_t var_254_3 = ((var_254_1 & var_24c_3) ^ var_248_1);
        int32_t var_258_3 = (((var_24c_1 ^ var_254_1) ^ var_24c_3) ^ var_250_2);
        *(arg1 + 0xe0) = var_24c_3;
        int32_t var_3c_57 = 0x39;
        *(arg1 + 0xe4) = var_254_3;
        int32_t var_3c_58 = 0x3a;
        *(arg1 + 0xe8) = ((var_248_1 & var_254_3) ^ var_258_3);
        int32_t var_3c_59 = 0x3b;
        *(arg1 + 0xec) = ((!(var_250_2 ^ var_248_1)) ^ (var_258_3 | var_254_3));
        int32_t var_3c_60 = 0x3c;
        int32_t rdx_155 = (RORD(((((rdx_135 ^ rdx_141) ^ rdx_147) ^ rdx_151) ^ 0x9e377985), 0x15));
        int32_t rdx_157 = (RORD(((((rdx_137 ^ rdx_145) ^ rdx_149) ^ rdx_155) ^ 0x9e377984), 0x15));
        int32_t rdx_159 = (RORD(((((rdx_139 ^ rdx_147) ^ rdx_151) ^ rdx_157) ^ 0x9e377987), 0x15));
        int32_t rdx_161 = (RORD(((((rdx_141 ^ rdx_149) ^ rdx_155) ^ rdx_159) ^ 0x9e377986), 0x15));
        int32_t var_270_1 = (rdx_157 ^ rdx_161);
        int32_t var_278_1 = (!rdx_161);
        int32_t var_274_1 = (rdx_159 ^ var_278_1);
        int32_t var_278_2 = (var_278_1 ^ rdx_155);
        int32_t var_270_3 = ((var_270_1 & var_278_2) ^ var_274_1);
        int32_t var_27c_1 = (var_270_1 ^ var_278_2);
        int32_t var_26c_1 = (rdx_155 ^ var_27c_1);
        int32_t var_274_3 = ((var_274_1 & var_27c_1) ^ var_26c_1);
        int32_t var_26c_2 = (var_26c_1 & var_270_3);
        int32_t var_278_3 = (var_278_2 ^ var_26c_2);
        *(arg1 + 0xf0) = var_270_3;
        int32_t var_3c_61 = 0x3d;
        *(arg1 + 0xf4) = (((var_27c_1 | var_270_3) ^ var_26c_2) ^ (var_274_3 & var_278_3));
        int32_t var_3c_62 = 0x3e;
        *(arg1 + 0xf8) = (!((var_26c_2 | var_278_3) ^ var_274_3));
        int32_t var_3c_63 = 0x3f;
        *(arg1 + 0xfc) = var_278_3;
        int32_t var_3c_64 = 0x40;
        int32_t rdx_165 = (RORD(((((rdx_145 ^ rdx_151) ^ rdx_157) ^ rdx_161) ^ 0x9e3779f9), 0x15));
        int32_t rdx_167 = (RORD(((((rdx_147 ^ rdx_155) ^ rdx_159) ^ rdx_165) ^ 0x9e3779f8), 0x15));
        int32_t rdx_169 = (RORD(((((rdx_149 ^ rdx_157) ^ rdx_161) ^ rdx_167) ^ 0x9e3779fb), 0x15));
        int32_t rdx_171 = (RORD(((((rdx_151 ^ rdx_159) ^ rdx_165) ^ rdx_169) ^ 0x9e3779fa), 0x15));
        int32_t var_290_1 = (rdx_165 | rdx_171);
        int32_t var_29c_1 = (rdx_171 ^ rdx_167);
        int32_t var_294_1 = (rdx_167 & rdx_165);
        int32_t var_298_1 = (rdx_169 ^ var_29c_1);
        int32_t var_2a0_2 = ((rdx_165 ^ rdx_169) | var_294_1);
        int32_t var_29c_3 = ((var_29c_1 & var_290_1) ^ var_2a0_2);
        int32_t var_290_2 = (var_290_1 ^ var_294_1);
        int32_t var_294_4 = (((var_294_1 ^ var_29c_3) | var_290_2) ^ var_298_1);
        *(arg1 + 0x100) = ((var_294_4 | var_29c_3) ^ (var_290_2 ^ var_29c_3));
        int32_t var_3c_65 = 0x41;
        *(arg1 + 0x104) = var_294_4;
        int32_t var_3c_66 = 0x42;
        *(arg1 + 0x108) = var_29c_3;
        int32_t var_3c_67 = 0x43;
        *(arg1 + 0x10c) = ((var_2a0_2 & var_290_2) ^ var_298_1);
        int32_t var_3c_68 = 0x44;
        int32_t rdx_175 = (RORD(((((rdx_155 ^ rdx_161) ^ rdx_167) ^ rdx_171) ^ 0x9e3779fd), 0x15));
        int32_t rdx_177 = (RORD(((((rdx_157 ^ rdx_165) ^ rdx_169) ^ rdx_175) ^ 0x9e3779fc), 0x15));
        int32_t rdx_179 = (RORD(((((rdx_159 ^ rdx_167) ^ rdx_171) ^ rdx_177) ^ 0x9e3779ff), 0x15));
        int32_t rdx_181 = (RORD(((((rdx_161 ^ rdx_169) ^ rdx_175) ^ rdx_179) ^ 0x9e3779fe), 0x15));
        int32_t var_2b4_2 = ((rdx_175 & rdx_179) ^ rdx_181);
        int32_t var_2bc_2 = ((rdx_179 ^ rdx_177) ^ var_2b4_2);
        int32_t var_2c0_2 = ((rdx_181 | rdx_175) ^ rdx_177);
        int32_t var_2c4_1 = (rdx_175 ^ var_2bc_2);
        int32_t var_2c0_4 = ((var_2c0_2 | var_2c4_1) ^ var_2b4_2);
        int32_t var_2c4_2 = (var_2c4_1 ^ (var_2b4_2 & var_2c0_2));
        *(arg1 + 0x110) = var_2bc_2;
        int32_t var_3c_69 = 0x45;
        *(arg1 + 0x114) = var_2c0_4;
        int32_t var_3c_70 = 0x46;
        *(arg1 + 0x118) = ((var_2c0_2 ^ var_2c0_4) ^ var_2c4_2);
        int32_t var_3c_71 = 0x47;
        *(arg1 + 0x11c) = (!var_2c4_2);
        int32_t var_3c_72 = 0x48;
        int32_t rdx_185 = (RORD(((((rdx_165 ^ rdx_171) ^ rdx_177) ^ rdx_181) ^ 0x9e3779f1), 0x15));
        int32_t rdx_187 = (RORD(((((rdx_167 ^ rdx_175) ^ rdx_179) ^ rdx_185) ^ 0x9e3779f0), 0x15));
        int32_t rdx_189 = (RORD(((((rdx_169 ^ rdx_177) ^ rdx_181) ^ rdx_187) ^ 0x9e3779f3), 0x15));
        int32_t rdx_191 = (RORD(((((rdx_171 ^ rdx_179) ^ rdx_185) ^ rdx_189) ^ 0x9e3779f2), 0x15));
        int32_t var_2d8_1 = (!rdx_185);
        int32_t var_2d8_2 = (var_2d8_1 & rdx_187);
        int32_t var_2e0_2 = ((!rdx_189) ^ var_2d8_2);
        int32_t var_2d8_3 = (var_2d8_2 | rdx_191);
        int32_t var_2e4_1 = (rdx_191 ^ var_2e0_2);
        int32_t var_2dc_1 = (rdx_187 ^ var_2d8_3);
        int32_t var_2d8_4 = (var_2d8_3 ^ var_2d8_1);
        int32_t var_2e8_1 = (var_2d8_1 | var_2dc_1);
        int32_t var_2dc_2 = (var_2dc_1 ^ var_2e4_1);
        int32_t var_2e0_4 = ((var_2e0_2 | var_2d8_4) & var_2e8_1);
        int32_t var_2d8_5 = (var_2d8_4 ^ var_2dc_2);
        *(arg1 + 0x120) = var_2e0_4;
        int32_t var_3c_73 = 0x49;
        *(arg1 + 0x124) = ((var_2d8_5 & var_2e0_4) ^ var_2e8_1);
        int32_t var_3c_74 = 0x4a;
        *(arg1 + 0x128) = var_2e4_1;
        int32_t var_3c_75 = 0x4b;
        *(arg1 + 0x12c) = ((var_2dc_2 & var_2e0_4) ^ var_2d8_5);
        int32_t var_3c_76 = 0x4c;
        int32_t rdx_195 = (RORD(((((rdx_175 ^ rdx_181) ^ rdx_187) ^ rdx_191) ^ 0x9e3779f5), 0x15));
        int32_t rdx_197 = (RORD(((((rdx_177 ^ rdx_185) ^ rdx_189) ^ rdx_195) ^ 0x9e3779f4), 0x15));
        int32_t rdx_199 = (RORD(((((rdx_179 ^ rdx_187) ^ rdx_191) ^ rdx_197) ^ 0x9e3779f7), 0x15));
        int32_t rdx_201 = (RORD(((((rdx_181 ^ rdx_189) ^ rdx_195) ^ rdx_199) ^ 0x9e3779f6), 0x15));
        int32_t var_308_1 = (rdx_201 ^ rdx_195);
        int32_t var_30c_1 = (rdx_197 ^ rdx_199);
        int32_t var_300_2 = ((rdx_197 & var_308_1) ^ rdx_195);
        int32_t var_2fc_2 = ((rdx_195 | var_308_1) ^ var_30c_1);
        int32_t var_30c_2 = (var_30c_1 ^ var_308_1);
        int32_t var_308_2 = (var_308_1 ^ rdx_199);
        int32_t var_30c_4 = ((!var_30c_2) | var_300_2);
        int32_t var_308_3 = (var_308_2 | var_2fc_2);
        *(arg1 + 0x130) = (((var_300_2 ^ var_308_2) ^ var_30c_4) ^ var_308_3);
        int32_t var_3c_77 = 0x4d;
        *(arg1 + 0x134) = (var_30c_4 ^ var_308_3);
        int32_t var_3c_78 = 0x4e;
        *(arg1 + 0x138) = ((rdx_199 | var_300_2) ^ var_30c_2);
        int32_t var_3c_79 = 0x4f;
        *(arg1 + 0x13c) = var_2fc_2;
        int32_t var_3c_80 = 0x50;
        int32_t rdx_205 = (RORD(((((rdx_185 ^ rdx_191) ^ rdx_197) ^ rdx_201) ^ 0x9e3779e9), 0x15));
        int32_t rdx_207 = (RORD(((((rdx_187 ^ rdx_195) ^ rdx_199) ^ rdx_205) ^ 0x9e3779e8), 0x15));
        int32_t rdx_209 = (RORD(((((rdx_189 ^ rdx_197) ^ rdx_201) ^ rdx_207) ^ 0x9e3779eb), 0x15));
        int32_t rdx_211 = (RORD(((((rdx_191 ^ rdx_199) ^ rdx_205) ^ rdx_209) ^ 0x9e3779ea), 0x15));
        int32_t var_324_2 = ((rdx_207 | rdx_209) ^ rdx_211);
        int32_t var_330_1 = (rdx_207 ^ rdx_209);
        int32_t var_328_1 = (rdx_209 ^ var_324_2);
        int32_t var_330_2 = (var_330_1 ^ var_328_1);
        int32_t var_320_2 = ((rdx_205 | var_330_2) ^ var_328_1);
        int32_t var_324_5 = (((var_324_2 | var_330_2) ^ rdx_205) ^ var_330_2);
        *(arg1 + 0x140) = (var_330_2 ^ ((!(var_328_1 ^ var_324_5)) | var_320_2));
        int32_t var_3c_81 = 0x51;
        *(arg1 + 0x144) = (((rdx_211 | var_330_1) & rdx_205) ^ var_324_2);
        int32_t var_3c_82 = 0x52;
        *(arg1 + 0x148) = ((var_324_5 & var_320_2) ^ var_330_2);
        int32_t var_3c_83 = 0x53;
        *(arg1 + 0x14c) = var_320_2;
        int32_t var_3c_84 = 0x54;
        int32_t rdx_215 = (RORD(((((rdx_195 ^ rdx_201) ^ rdx_207) ^ rdx_211) ^ 0x9e3779ed), 0x15));
        int32_t rdx_217 = (RORD(((((rdx_197 ^ rdx_205) ^ rdx_209) ^ rdx_215) ^ 0x9e3779ec), 0x15));
        int32_t rdx_219 = (RORD(((((rdx_199 ^ rdx_207) ^ rdx_211) ^ rdx_217) ^ 0x9e3779ef), 0x15));
        int32_t rdx_221 = (RORD(((((rdx_201 ^ rdx_209) ^ rdx_215) ^ rdx_219) ^ 0x9e3779ee), 0x15));
        int32_t var_34c_1 = (!rdx_219);
        int32_t var_344_1 = (rdx_215 ^ rdx_221);
        int32_t var_350_2 = ((rdx_221 & rdx_215) ^ var_34c_1);
        int32_t var_348_1 = (rdx_217 ^ var_350_2);
        int32_t var_344_2 = (var_344_1 | var_348_1);
        int32_t var_34c_4 = (((var_34c_1 | rdx_221) ^ var_344_1) ^ var_348_1);
        int32_t var_344_4 = ((var_344_2 | var_350_2) ^ var_34c_4);
        int32_t var_354_3 = (((rdx_221 ^ var_344_2) ^ var_350_2) ^ var_344_4);
        *(arg1 + 0x150) = var_344_4;
        int32_t var_3c_85 = 0x55;
        *(arg1 + 0x154) = var_348_1;
        int32_t var_3c_86 = 0x56;
        *(arg1 + 0x158) = var_354_3;
        int32_t var_3c_87 = 0x57;
        *(arg1 + 0x15c) = ((var_34c_4 & var_354_3) ^ (!var_350_2));
        int32_t var_3c_88 = 0x58;
        int32_t rdx_225 = (RORD(((((rdx_205 ^ rdx_211) ^ rdx_217) ^ rdx_221) ^ 0x9e3779e1), 0x15));
        int32_t rdx_227 = (RORD(((((rdx_207 ^ rdx_215) ^ rdx_219) ^ rdx_225) ^ 0x9e3779e0), 0x15));
        int32_t rdx_229 = (RORD(((((rdx_209 ^ rdx_217) ^ rdx_221) ^ rdx_227) ^ 0x9e3779e3), 0x15));
        int32_t rdx_231 = (RORD(((((rdx_211 ^ rdx_219) ^ rdx_225) ^ rdx_229) ^ 0x9e3779e2), 0x15));
        int32_t var_368_1 = (rdx_225 ^ rdx_227);
        int32_t var_36c_1 = (rdx_227 ^ rdx_231);
        int32_t var_374_1 = (!rdx_231);
        int32_t var_370_1 = (rdx_229 ^ var_374_1);
        int32_t var_36c_3 = ((var_36c_1 & var_368_1) ^ var_370_1);
        int32_t var_370_2 = (var_370_1 | var_36c_1);
        int32_t var_374_3 = ((var_374_1 & var_36c_3) ^ var_368_1);
        int32_t var_378_3 = (((var_36c_1 ^ var_374_1) ^ var_36c_3) ^ var_370_2);
        *(arg1 + 0x160) = var_36c_3;
        int32_t var_3c_89 = 0x59;
        *(arg1 + 0x164) = var_374_3;
        int32_t var_3c_90 = 0x5a;
        *(arg1 + 0x168) = ((var_368_1 & var_374_3) ^ var_378_3);
        int32_t var_3c_91 = 0x5b;
        *(arg1 + 0x16c) = ((!(var_370_2 ^ var_368_1)) ^ (var_378_3 | var_374_3));
        int32_t var_3c_92 = 0x5c;
        int32_t rdx_235 = (RORD(((((rdx_215 ^ rdx_221) ^ rdx_227) ^ rdx_231) ^ 0x9e3779e5), 0x15));
        int32_t rdx_237 = (RORD(((((rdx_217 ^ rdx_225) ^ rdx_229) ^ rdx_235) ^ 0x9e3779e4), 0x15));
        int32_t rdx_239 = (RORD(((((rdx_219 ^ rdx_227) ^ rdx_231) ^ rdx_237) ^ 0x9e3779e7), 0x15));
        int32_t rdx_241 = (RORD(((((rdx_221 ^ rdx_229) ^ rdx_235) ^ rdx_239) ^ 0x9e3779e6), 0x15));
        int32_t var_390_1 = (rdx_237 ^ rdx_241);
        int32_t var_398_1 = (!rdx_241);
        int32_t var_394_1 = (rdx_239 ^ var_398_1);
        int32_t var_398_2 = (var_398_1 ^ rdx_235);
        int32_t var_390_3 = ((var_390_1 & var_398_2) ^ var_394_1);
        int32_t var_39c_1 = (var_390_1 ^ var_398_2);
        int32_t var_38c_1 = (rdx_235 ^ var_39c_1);
        int32_t var_394_3 = ((var_394_1 & var_39c_1) ^ var_38c_1);
        int32_t var_38c_2 = (var_38c_1 & var_390_3);
        int32_t var_398_3 = (var_398_2 ^ var_38c_2);
        *(arg1 + 0x170) = var_390_3;
        int32_t var_3c_93 = 0x5d;
        *(arg1 + 0x174) = (((var_39c_1 | var_390_3) ^ var_38c_2) ^ (var_394_3 & var_398_3));
        int32_t var_3c_94 = 0x5e;
        *(arg1 + 0x178) = (!((var_38c_2 | var_398_3) ^ var_394_3));
        int32_t var_3c_95 = 0x5f;
        *(arg1 + 0x17c) = var_398_3;
        int32_t var_3c_96 = 0x60;
        int32_t rdx_245 = (RORD(((((rdx_225 ^ rdx_231) ^ rdx_237) ^ rdx_241) ^ 0x9e3779d9), 0x15));
        int32_t rdx_247 = (RORD(((((rdx_227 ^ rdx_235) ^ rdx_239) ^ rdx_245) ^ 0x9e3779d8), 0x15));
        int32_t rdx_249 = (RORD(((((rdx_229 ^ rdx_237) ^ rdx_241) ^ rdx_247) ^ 0x9e3779db), 0x15));
        int32_t rdx_251 = (RORD(((((rdx_231 ^ rdx_239) ^ rdx_245) ^ rdx_249) ^ 0x9e3779da), 0x15));
        int32_t var_3b0_1 = (rdx_245 | rdx_251);
        int32_t var_3bc_1 = (rdx_251 ^ rdx_247);
        int32_t var_3b4_1 = (rdx_247 & rdx_245);
        int32_t var_3b8_1 = (rdx_249 ^ var_3bc_1);
        int32_t var_3c0_2 = ((rdx_245 ^ rdx_249) | var_3b4_1);
        int32_t var_3bc_3 = ((var_3bc_1 & var_3b0_1) ^ var_3c0_2);
        int32_t var_3b0_2 = (var_3b0_1 ^ var_3b4_1);
        int32_t var_3b4_4 = (((var_3b4_1 ^ var_3bc_3) | var_3b0_2) ^ var_3b8_1);
        *(arg1 + 0x180) = ((var_3b4_4 | var_3bc_3) ^ (var_3b0_2 ^ var_3bc_3));
        int32_t var_3c_97 = 0x61;
        *(arg1 + 0x184) = var_3b4_4;
        int32_t var_3c_98 = 0x62;
        *(arg1 + 0x188) = var_3bc_3;
        int32_t var_3c_99 = 0x63;
        *(arg1 + 0x18c) = ((var_3c0_2 & var_3b0_2) ^ var_3b8_1);
        int32_t var_3c_100 = 0x64;
        int64_t rax_1194 = (rax ^ *(fsbase + 0x28));
        if (rax_1194 == 0)
        {
            return rax_1194;
        }
        __stack_chk_fail();
        /* no return */
    }
    fprintf(stderr, "invalid key size: %lu\n", arg3);
    exit(1);
    /* no return */
}

uint64_t decode32le(char* arg1)
{
    return ((arg1[3] << 0x18) | ((*arg1 | (arg1[1] << 8)) | (arg1[2] << 0x10)));
}

int64_t sosemanuk_init(int32_t* arg1, int32_t* arg2, int64_t arg3,
    uint64_t arg4)
{
    void* fsbase;
    int64_t rax = *(fsbase + 0x28);
    void var_28;
    if (arg4 > 0xf)
    {
        memcpy(&var_28, arg3, 0x10);
    }
    else
    {
        if (arg4 != 0)
        {
            memcpy(&var_28, arg3, arg4);
        }
        memset((&var_28 + arg4), 0, (0x10 - arg4));
    }
    int32_t var_5c_1 = (decode32le(&var_28) ^ *arg2);
    void var_24;
    int32_t var_58_1 = (decode32le(&var_24) ^ arg2[1]);
    void var_20;
    int32_t var_54_1 = (decode32le(&var_20) ^ arg2[2]);
    void var_1c;
    int32_t var_50_2 = ((decode32le(&var_1c) ^ arg2[3]) ^ var_5c_1);
    int32_t var_4c_1 = (var_58_1 ^ var_54_1);
    int32_t var_58_3 = ((var_58_1 & var_50_2) ^ var_5c_1);
    int32_t var_5c_3 = ((var_5c_1 | var_50_2) ^ var_4c_1);
    int32_t var_4c_2 = (var_4c_1 ^ var_50_2);
    int32_t var_50_3 = (var_50_2 ^ var_54_1);
    int32_t var_4c_4 = ((!var_4c_2) | var_58_3);
    int32_t var_50_4 = (var_50_3 | var_5c_3);
    int32_t var_58_7 = (RORD((((var_58_3 ^ var_50_3) ^ var_4c_4) ^ var_50_4), 0x13));
    int32_t var_54_4 = (RORD(((var_54_1 | var_58_3) ^ var_4c_2), 0x1d));
    int32_t var_4c_7 = (RORD((var_54_4 ^ ((var_4c_4 ^ var_50_4) ^ var_58_7)), 0x1f));
    int32_t var_5c_5 = (RORD(((var_5c_3 ^ var_54_4) ^ (var_58_7 << 3)), 0x19));
    int32_t var_4c_8 = (var_4c_7 ^ arg2[5]);
    int32_t var_5c_6 = (var_5c_5 ^ arg2[7]);
    int32_t var_58_11 = (!((RORD((var_5c_5 ^ (var_58_7 ^ var_4c_7)), 0x1b)) ^ arg2[4]));
    int32_t var_58_12 = (var_58_11 & var_4c_8);
    int32_t var_54_9 = ((!((RORD(((var_54_4 ^ var_5c_5) ^ (var_4c_7 << 7)), 0xa)) ^ arg2[6])) ^ var_58_12);
    int32_t var_58_13 = (var_58_12 | var_5c_6);
    int32_t var_5c_7 = (var_5c_6 ^ var_54_9);
    int32_t var_4c_9 = (var_4c_8 ^ var_58_13);
    int32_t var_58_14 = (var_58_13 ^ var_58_11);
    int32_t var_50_6 = (var_58_11 | var_4c_9);
    int32_t var_4c_10 = (var_4c_9 ^ var_5c_7);
    int32_t var_54_11 = ((var_54_9 | var_58_14) & var_50_6);
    int32_t var_58_15 = (var_58_14 ^ var_4c_10);
    int32_t var_54_12 = (RORD(var_54_11, 0x13));
    int32_t var_5c_8 = (RORD(var_5c_7, 0x1d));
    int32_t var_58_19 = (RORD((var_5c_8 ^ (((var_58_15 & var_54_11) ^ var_50_6) ^ var_54_12)), 0x1f));
    int32_t var_4c_14 = (RORD(((((var_4c_10 & var_54_11) ^ var_58_15) ^ var_5c_8) ^ (var_54_12 << 3)), 0x19));
    int32_t var_54_15 = ((RORD((var_4c_14 ^ (var_54_12 ^ var_58_19)), 0x1b)) ^ arg2[8]);
    int32_t var_58_20 = (var_58_19 ^ arg2[9]);
    int32_t var_5c_11 = ((RORD(((var_5c_8 ^ var_4c_14) ^ (var_58_19 << 7)), 0xa)) ^ arg2[0xa]);
    int32_t var_4c_15 = (var_4c_14 ^ arg2[0xb]);
    int32_t var_54_17 = ((var_54_15 & var_5c_11) ^ var_4c_15);
    int32_t var_5c_13 = ((var_5c_11 ^ var_58_20) ^ var_54_17);
    int32_t var_4c_17 = ((var_4c_15 | var_54_15) ^ var_58_20);
    int32_t var_50_8 = (var_54_15 ^ var_5c_13);
    int32_t var_4c_19 = ((var_4c_17 | var_50_8) ^ var_54_17);
    int32_t var_50_9 = (var_50_8 ^ (var_54_17 & var_4c_17));
    int32_t var_5c_14 = (RORD(var_5c_13, 0x13));
    int32_t var_58_24 = (RORD(((var_4c_17 ^ var_4c_19) ^ var_50_9), 0x1d));
    int32_t var_4c_21 = (RORD((var_58_24 ^ (var_4c_19 ^ var_5c_14)), 0x1f));
    int32_t var_50_12 = (RORD((((!var_50_9) ^ var_58_24) ^ (var_5c_14 << 3)), 0x19));
    int32_t var_5c_17 = ((RORD((var_50_12 ^ (var_5c_14 ^ var_4c_21)), 0x1b)) ^ arg2[0xc]);
    int32_t var_4c_22 = (var_4c_21 ^ arg2[0xd]);
    int32_t var_58_27 = ((RORD(((var_58_24 ^ var_50_12) ^ (var_4c_21 << 7)), 0xa)) ^ arg2[0xe]);
    int32_t var_50_13 = (var_50_12 ^ arg2[0xf]);
    int32_t var_5c_18 = (var_5c_17 | var_50_13);
    int32_t var_50_14 = (var_50_13 ^ var_4c_22);
    int32_t var_4c_23 = (var_4c_22 & var_5c_17);
    int32_t var_58_28 = (var_58_27 ^ var_50_14);
    int32_t var_54_21 = ((var_5c_17 ^ var_58_27) | var_4c_23);
    int32_t var_50_16 = ((var_50_14 & var_5c_18) ^ var_54_21);
    int32_t var_5c_19 = (var_5c_18 ^ var_4c_23);
    int32_t var_4c_26 = (((var_4c_23 ^ var_50_16) | var_5c_19) ^ var_58_28);
    int32_t var_4c_29 = (RORD(((var_4c_26 | var_50_16) ^ (var_5c_19 ^ var_50_16)), 0x13));
    int32_t var_50_17 = (RORD(var_50_16, 0x1d));
    int32_t var_58_31 = (RORD((var_50_17 ^ (var_4c_26 ^ var_4c_29)), 0x1f));
    int32_t var_54_25 = (RORD(((((var_54_21 & var_5c_19) ^ var_58_28) ^ var_50_17) ^ (var_4c_29 << 3)), 0x19));
    int32_t var_4c_32 = ((RORD((var_54_25 ^ (var_4c_29 ^ var_58_31)), 0x1b)) ^ arg2[0x10]);
    int32_t var_54_26 = (var_54_25 ^ arg2[0x13]);
    int32_t var_58_33 = ((var_58_31 ^ arg2[0x11]) ^ var_54_26);
    int32_t var_54_27 = (!var_54_26);
    int32_t var_50_21 = (((RORD(((var_50_17 ^ var_54_25) ^ (var_58_31 << 7)), 0xa)) ^ arg2[0x12]) ^ var_54_27);
    int32_t var_54_28 = (var_54_27 ^ var_4c_32);
    int32_t var_58_35 = ((var_58_33 & var_54_28) ^ var_50_21);
    int32_t var_5c_22 = (var_58_33 ^ var_54_28);
    int32_t var_4c_33 = (var_4c_32 ^ var_5c_22);
    int32_t var_50_23 = ((var_50_21 & var_5c_22) ^ var_4c_33);
    int32_t var_4c_34 = (var_4c_33 & var_58_35);
    int32_t var_54_29 = (var_54_28 ^ var_4c_34);
    int32_t var_58_36 = (RORD(var_58_35, 0x13));
    int32_t var_4c_38 = (RORD((!((var_4c_34 | var_54_29) ^ var_50_23)), 0x1d));
    int32_t var_5c_27 = (RORD((var_4c_38 ^ ((((var_5c_22 | var_58_35) ^ var_4c_34) ^ (var_50_23 & var_54_29)) ^ var_58_36)), 0x1f));
    int32_t var_54_31 = (RORD(((var_54_29 ^ var_4c_38) ^ (var_58_36 << 3)), 0x19));
    int32_t var_5c_28 = (var_5c_27 ^ arg2[0x15]);
    int32_t var_54_32 = (var_54_31 ^ arg2[0x17]);
    int32_t var_58_40 = (((RORD((var_54_31 ^ (var_58_36 ^ var_5c_27)), 0x1b)) ^ arg2[0x14]) ^ var_5c_28);
    int32_t var_5c_29 = (var_5c_28 ^ var_54_32);
    int32_t var_54_33 = (!var_54_32);
    int32_t var_4c_42 = (((RORD(((var_4c_38 ^ var_54_31) ^ (var_5c_27 << 7)), 0xa)) ^ arg2[0x16]) ^ var_54_33);
    int32_t var_5c_31 = ((var_5c_29 & var_58_40) ^ var_4c_42);
    int32_t var_4c_43 = (var_4c_42 | var_5c_29);
    int32_t var_54_35 = ((var_54_33 & var_5c_31) ^ var_58_40);
    int32_t var_50_28 = (((var_5c_29 ^ var_54_33) ^ var_5c_31) ^ var_4c_43);
    int32_t var_5c_32 = (RORD(var_5c_31, 0x13));
    int32_t var_58_43 = (RORD(((var_58_40 & var_54_35) ^ var_50_28), 0x1d));
    int32_t var_54_37 = (RORD((var_58_43 ^ (var_54_35 ^ var_5c_32)), 0x1f));
    int32_t var_4c_48 = (RORD(((((!(var_4c_43 ^ var_58_40)) ^ (var_50_28 | var_54_35)) ^ var_58_43) ^ (var_5c_32 << 3)), 0x19));
    int32_t var_5c_35 = ((RORD((var_4c_48 ^ (var_5c_32 ^ var_54_37)), 0x1b)) ^ arg2[0x18]);
    int32_t var_4c_49 = (var_4c_48 ^ arg2[0x1b]);
    int32_t var_58_47 = (!((RORD(((var_58_43 ^ var_4c_48) ^ (var_54_37 << 7)), 0xa)) ^ arg2[0x1a]));
    int32_t var_5c_36 = (var_5c_35 ^ var_4c_49);
    int32_t var_4c_51 = ((var_4c_49 & var_5c_35) ^ var_58_47);
    int32_t var_54_39 = ((var_54_37 ^ arg2[0x19]) ^ var_4c_51);
    int32_t var_5c_37 = (var_5c_36 | var_54_39);
    int32_t var_58_50 = (((var_58_47 | var_4c_49) ^ var_5c_36) ^ var_54_39);
    int32_t var_5c_39 = ((var_5c_37 | var_4c_51) ^ var_58_50);
    int32_t var_50_33 = (((var_4c_49 ^ var_5c_37) ^ var_4c_51) ^ var_5c_39);
    int32_t var_5c_40 = (RORD(var_5c_39, 0x13));
    int32_t var_50_34 = (RORD(var_50_33, 0x1d));
    int32_t var_54_41 = (RORD((var_50_34 ^ (var_54_39 ^ var_5c_40)), 0x1f));
    int32_t var_58_54 = (RORD(((((var_58_50 & var_50_33) ^ (!var_4c_51)) ^ var_50_34) ^ (var_5c_40 << 3)), 0x19));
    int32_t var_5c_43 = ((RORD((var_58_54 ^ (var_5c_40 ^ var_54_41)), 0x1b)) ^ arg2[0x1c]);
    int32_t var_54_42 = (var_54_41 ^ arg2[0x1d]);
    int32_t var_50_37 = ((RORD(((var_50_34 ^ var_58_54) ^ (var_54_41 << 7)), 0xa)) ^ arg2[0x1e]);
    int32_t var_58_55 = (var_58_54 ^ arg2[0x1f]);
    int32_t var_54_44 = ((var_54_42 | var_50_37) ^ var_58_55);
    int32_t var_4c_54 = (var_54_42 ^ var_50_37);
    int32_t var_50_38 = (var_50_37 ^ var_54_44);
    int32_t var_4c_55 = (var_4c_54 ^ var_50_38);
    int32_t var_5c_45 = ((var_5c_43 | var_4c_55) ^ var_50_38);
    int32_t var_54_47 = (((var_54_44 | var_4c_55) ^ var_5c_43) ^ var_4c_55);
    int32_t var_4c_57 = (RORD((var_4c_55 ^ ((!(var_50_38 ^ var_54_47)) | var_5c_45)), 0x13));
    int32_t var_54_50 = (RORD(((var_54_47 & var_5c_45) ^ var_4c_55), 0x1d));
    int32_t var_58_60 = (RORD((var_54_50 ^ ((((var_58_55 | var_4c_54) & var_5c_43) ^ var_54_44) ^ var_4c_57)), 0x1f));
    int32_t var_5c_47 = (RORD(((var_5c_45 ^ var_54_50) ^ (var_4c_57 << 3)), 0x19));
    int32_t var_4c_60 = ((RORD((var_5c_47 ^ (var_4c_57 ^ var_58_60)), 0x1b)) ^ arg2[0x20]);
    int32_t var_58_61 = (var_58_60 ^ arg2[0x21]);
    int32_t var_54_53 = ((RORD(((var_54_50 ^ var_5c_47) ^ (var_58_60 << 7)), 0xa)) ^ arg2[0x22]);
    int32_t var_5c_49 = ((var_5c_47 ^ arg2[0x23]) ^ var_4c_60);
    int32_t var_50_43 = (var_58_61 ^ var_54_53);
    int32_t var_58_63 = ((var_58_61 & var_5c_49) ^ var_4c_60);
    int32_t var_4c_62 = ((var_4c_60 | var_5c_49) ^ var_50_43);
    int32_t var_50_44 = (var_50_43 ^ var_5c_49);
    int32_t var_5c_50 = (var_5c_49 ^ var_54_53);
    int32_t var_50_46 = ((!var_50_44) | var_58_63);
    int32_t var_5c_51 = (var_5c_50 | var_4c_62);
    int32_t var_58_67 = (RORD((((var_58_63 ^ var_5c_50) ^ var_50_46) ^ var_5c_51), 0x13));
    int32_t var_54_56 = (RORD(((var_54_53 | var_58_63) ^ var_50_44), 0x1d));
    int32_t var_50_49 = (RORD((var_54_56 ^ ((var_50_46 ^ var_5c_51) ^ var_58_67)), 0x1f));
    int32_t var_4c_64 = (RORD(((var_4c_62 ^ var_54_56) ^ (var_58_67 << 3)), 0x19));
    int32_t var_50_50 = (var_50_49 ^ arg2[0x25]);
    int32_t var_4c_65 = (var_4c_64 ^ arg2[0x27]);
    int32_t var_58_71 = (!((RORD((var_4c_64 ^ (var_58_67 ^ var_50_49)), 0x1b)) ^ arg2[0x24]));
    int32_t var_58_72 = (var_58_71 & var_50_50);
    int32_t var_54_61 = ((!((RORD(((var_54_56 ^ var_4c_64) ^ (var_50_49 << 7)), 0xa)) ^ arg2[0x26])) ^ var_58_72);
    int32_t var_58_73 = (var_58_72 | var_4c_65);
    int32_t var_4c_66 = (var_4c_65 ^ var_54_61);
    int32_t var_50_51 = (var_50_50 ^ var_58_73);
    int32_t var_58_74 = (var_58_73 ^ var_58_71);
    int32_t var_5c_53 = (var_58_71 | var_50_51);
    int32_t var_50_52 = (var_50_51 ^ var_4c_66);
    int32_t var_54_63 = ((var_54_61 | var_58_74) & var_5c_53);
    int32_t var_58_75 = (var_58_74 ^ var_50_52);
    int32_t var_54_64 = (RORD(var_54_63, 0x13));
    int32_t var_4c_67 = (RORD(var_4c_66, 0x1d));
    int32_t var_58_79 = (RORD((var_4c_67 ^ (((var_58_75 & var_54_63) ^ var_5c_53) ^ var_54_64)), 0x1f));
    int32_t var_50_56 = (RORD(((((var_50_52 & var_54_63) ^ var_58_75) ^ var_4c_67) ^ (var_54_64 << 3)), 0x19));
    int32_t var_54_67 = ((RORD((var_50_56 ^ (var_54_64 ^ var_58_79)), 0x1b)) ^ arg2[0x28]);
    int32_t var_58_80 = (var_58_79 ^ arg2[0x29]);
    int32_t var_4c_70 = ((RORD(((var_4c_67 ^ var_50_56) ^ (var_58_79 << 7)), 0xa)) ^ arg2[0x2a]);
    int32_t var_50_57 = (var_50_56 ^ arg2[0x2b]);
    int32_t var_54_69 = ((var_54_67 & var_4c_70) ^ var_50_57);
    int32_t var_4c_72 = ((var_4c_70 ^ var_58_80) ^ var_54_69);
    int32_t var_50_59 = ((var_50_57 | var_54_67) ^ var_58_80);
    int32_t var_5c_55 = (var_54_67 ^ var_4c_72);
    int32_t var_50_61 = ((var_50_59 | var_5c_55) ^ var_54_69);
    int32_t var_5c_56 = (var_5c_55 ^ (var_54_69 & var_50_59));
    int32_t var_4c_73 = (RORD(var_4c_72, 0x13));
    int32_t var_58_84 = (RORD(((var_50_59 ^ var_50_61) ^ var_5c_56), 0x1d));
    int32_t var_50_63 = (RORD((var_58_84 ^ (var_50_61 ^ var_4c_73)), 0x1f));
    int32_t var_5c_59 = (RORD((((!var_5c_56) ^ var_58_84) ^ (var_4c_73 << 3)), 0x19));
    int32_t var_4c_76 = ((RORD((var_5c_59 ^ (var_4c_73 ^ var_50_63)), 0x1b)) ^ arg2[0x2c]);
    int32_t var_50_64 = (var_50_63 ^ arg2[0x2d]);
    int32_t var_58_87 = ((RORD(((var_58_84 ^ var_5c_59) ^ (var_50_63 << 7)), 0xa)) ^ arg2[0x2e]);
    int32_t var_5c_60 = (var_5c_59 ^ arg2[0x2f]);
    int32_t var_4c_77 = (var_4c_76 | var_5c_60);
    int32_t var_5c_61 = (var_5c_60 ^ var_50_64);
    int32_t var_50_65 = (var_50_64 & var_4c_76);
    int32_t var_58_88 = (var_58_87 ^ var_5c_61);
    int32_t var_54_73 = ((var_4c_76 ^ var_58_87) | var_50_65);
    int32_t var_5c_63 = ((var_5c_61 & var_4c_77) ^ var_54_73);
    int32_t var_4c_78 = (var_4c_77 ^ var_50_65);
    int32_t var_50_68 = (((var_50_65 ^ var_5c_63) | var_4c_78) ^ var_58_88);
    int32_t var_50_71 = (RORD(((var_50_68 | var_5c_63) ^ (var_4c_78 ^ var_5c_63)), 0x13));
    int32_t var_5c_64 = (RORD(var_5c_63, 0x1d));
    int32_t var_58_91 = (RORD((var_5c_64 ^ (var_50_68 ^ var_50_71)), 0x1f));
    int32_t var_54_77 = (RORD(((((var_54_73 & var_4c_78) ^ var_58_88) ^ var_5c_64) ^ (var_50_71 << 3)), 0x19));
    int32_t var_50_73 = (RORD((var_54_77 ^ (var_50_71 ^ var_58_91)), 0x1b));
    int32_t var_5c_66 = (RORD(((var_5c_64 ^ var_54_77) ^ (var_58_91 << 7)), 0xa));
    arg1[9] = var_50_73;
    arg1[8] = var_58_91;
    arg1[7] = var_5c_66;
    arg1[6] = var_54_77;
    int32_t var_50_74 = (var_50_73 ^ arg2[0x30]);
    int32_t var_54_78 = (var_54_77 ^ arg2[0x33]);
    int32_t var_58_93 = ((var_58_91 ^ arg2[0x31]) ^ var_54_78);
    int32_t var_54_79 = (!var_54_78);
    int32_t var_5c_68 = ((var_5c_66 ^ arg2[0x32]) ^ var_54_79);
    int32_t var_54_80 = (var_54_79 ^ var_50_74);
    int32_t var_58_95 = ((var_58_93 & var_54_80) ^ var_5c_68);
    int32_t var_4c_81 = (var_58_93 ^ var_54_80);
    int32_t var_50_75 = (var_50_74 ^ var_4c_81);
    int32_t var_5c_70 = ((var_5c_68 & var_4c_81) ^ var_50_75);
    int32_t var_50_76 = (var_50_75 & var_58_95);
    int32_t var_54_81 = (var_54_80 ^ var_50_76);
    int32_t var_58_96 = (RORD(var_58_95, 0x13));
    int32_t var_50_80 = (RORD((!((var_50_76 | var_54_81) ^ var_5c_70)), 0x1d));
    int32_t var_4c_86 = (RORD((var_50_80 ^ ((((var_4c_81 | var_58_95) ^ var_50_76) ^ (var_5c_70 & var_54_81)) ^ var_58_96)), 0x1f));
    int32_t var_54_83 = (RORD(((var_54_81 ^ var_50_80) ^ (var_58_96 << 3)), 0x19));
    int32_t var_4c_87 = (var_4c_86 ^ arg2[0x35]);
    int32_t var_54_84 = (var_54_83 ^ arg2[0x37]);
    int32_t var_58_100 = (((RORD((var_54_83 ^ (var_58_96 ^ var_4c_86)), 0x1b)) ^ arg2[0x34]) ^ var_4c_87);
    int32_t var_4c_88 = (var_4c_87 ^ var_54_84);
    int32_t var_54_85 = (!var_54_84);
    int32_t var_50_84 = (((RORD(((var_50_80 ^ var_54_83) ^ (var_4c_86 << 7)), 0xa)) ^ arg2[0x36]) ^ var_54_85);
    int32_t var_4c_90 = ((var_4c_88 & var_58_100) ^ var_50_84);
    int32_t var_50_85 = (var_50_84 | var_4c_88);
    int32_t var_54_87 = ((var_54_85 & var_4c_90) ^ var_58_100);
    int32_t var_5c_75 = (((var_4c_88 ^ var_54_85) ^ var_4c_90) ^ var_50_85);
    int32_t var_4c_91 = (RORD(var_4c_90, 0x13));
    int32_t var_58_103 = (RORD(((var_58_100 & var_54_87) ^ var_5c_75), 0x1d));
    int32_t var_54_89 = (RORD((var_58_103 ^ (var_54_87 ^ var_4c_91)), 0x1f));
    int32_t var_50_90 = (RORD(((((!(var_50_85 ^ var_58_100)) ^ (var_5c_75 | var_54_87)) ^ var_58_103) ^ (var_4c_91 << 3)), 0x19));
    int32_t var_4c_94 = ((RORD((var_50_90 ^ (var_4c_91 ^ var_54_89)), 0x1b)) ^ arg2[0x38]);
    int32_t var_50_91 = (var_50_90 ^ arg2[0x3b]);
    int32_t var_58_107 = (!((RORD(((var_58_103 ^ var_50_90) ^ (var_54_89 << 7)), 0xa)) ^ arg2[0x3a]));
    int32_t var_4c_95 = (var_4c_94 ^ var_50_91);
    int32_t var_50_93 = ((var_50_91 & var_4c_94) ^ var_58_107);
    int32_t var_54_91 = ((var_54_89 ^ arg2[0x39]) ^ var_50_93);
    int32_t var_4c_96 = (var_4c_95 | var_54_91);
    int32_t var_58_110 = (((var_58_107 | var_50_91) ^ var_4c_95) ^ var_54_91);
    int32_t var_4c_98 = ((var_4c_96 | var_50_93) ^ var_58_110);
    int32_t var_5c_80 = (((var_50_91 ^ var_4c_96) ^ var_50_93) ^ var_4c_98);
    int32_t var_4c_99 = (RORD(var_4c_98, 0x13));
    int32_t var_5c_81 = (RORD(var_5c_80, 0x1d));
    int32_t var_54_93 = (RORD((var_5c_81 ^ (var_54_91 ^ var_4c_99)), 0x1f));
    int32_t var_58_114 = (RORD(((((var_58_110 & var_5c_80) ^ (!var_50_93)) ^ var_5c_81) ^ (var_4c_99 << 3)), 0x19));
    int32_t var_4c_102 = ((RORD((var_58_114 ^ (var_4c_99 ^ var_54_93)), 0x1b)) ^ arg2[0x3c]);
    int32_t var_54_94 = (var_54_93 ^ arg2[0x3d]);
    int32_t var_5c_84 = ((RORD(((var_5c_81 ^ var_58_114) ^ (var_54_93 << 7)), 0xa)) ^ arg2[0x3e]);
    int32_t var_58_115 = (var_58_114 ^ arg2[0x3f]);
    int32_t var_54_96 = ((var_54_94 | var_5c_84) ^ var_58_115);
    int32_t var_50_96 = (var_54_94 ^ var_5c_84);
    int32_t var_5c_85 = (var_5c_84 ^ var_54_96);
    int32_t var_50_97 = (var_50_96 ^ var_5c_85);
    int32_t var_4c_104 = ((var_4c_102 | var_50_97) ^ var_5c_85);
    int32_t var_54_99 = (((var_54_96 | var_50_97) ^ var_4c_102) ^ var_50_97);
    int32_t var_50_99 = (RORD((var_50_97 ^ ((!(var_5c_85 ^ var_54_99)) | var_4c_104)), 0x13));
    int32_t var_54_102 = (RORD(((var_54_99 & var_4c_104) ^ var_50_97), 0x1d));
    int32_t var_58_120 = (RORD((var_54_102 ^ ((((var_58_115 | var_50_96) & var_4c_102) ^ var_54_96) ^ var_50_99)), 0x1f));
    int32_t var_4c_106 = (RORD(((var_4c_104 ^ var_54_102) ^ (var_50_99 << 3)), 0x19));
    int32_t var_50_102 = ((RORD((var_4c_106 ^ (var_50_99 ^ var_58_120)), 0x1b)) ^ arg2[0x40]);
    int32_t var_58_121 = (var_58_120 ^ arg2[0x41]);
    int32_t var_54_105 = ((RORD(((var_54_102 ^ var_4c_106) ^ (var_58_120 << 7)), 0xa)) ^ arg2[0x42]);
    int32_t var_4c_108 = ((var_4c_106 ^ arg2[0x43]) ^ var_50_102);
    int32_t var_5c_90 = (var_58_121 ^ var_54_105);
    int32_t var_58_123 = ((var_58_121 & var_4c_108) ^ var_50_102);
    int32_t var_50_104 = ((var_50_102 | var_4c_108) ^ var_5c_90);
    int32_t var_5c_91 = (var_5c_90 ^ var_4c_108);
    int32_t var_4c_109 = (var_4c_108 ^ var_54_105);
    int32_t var_5c_93 = ((!var_5c_91) | var_58_123);
    int32_t var_4c_110 = (var_4c_109 | var_50_104);
    int32_t var_58_127 = (RORD((((var_58_123 ^ var_4c_109) ^ var_5c_93) ^ var_4c_110), 0x13));
    int32_t var_54_108 = (RORD(((var_54_105 | var_58_123) ^ var_5c_91), 0x1d));
    int32_t var_5c_96 = (RORD((var_54_108 ^ ((var_5c_93 ^ var_4c_110) ^ var_58_127)), 0x1f));
    int32_t var_50_106 = (RORD(((var_50_104 ^ var_54_108) ^ (var_58_127 << 3)), 0x19));
    int32_t var_5c_97 = (var_5c_96 ^ arg2[0x45]);
    int32_t var_50_107 = (var_50_106 ^ arg2[0x47]);
    int32_t var_58_131 = (!((RORD((var_50_106 ^ (var_58_127 ^ var_5c_96)), 0x1b)) ^ arg2[0x44]));
    int32_t var_58_132 = (var_58_131 & var_5c_97);
    int32_t var_54_113 = ((!((RORD(((var_54_108 ^ var_50_106) ^ (var_5c_96 << 7)), 0xa)) ^ arg2[0x46])) ^ var_58_132);
    int32_t var_58_133 = (var_58_132 | var_50_107);
    int32_t var_50_108 = (var_50_107 ^ var_54_113);
    int32_t var_5c_98 = (var_5c_97 ^ var_58_133);
    int32_t var_58_134 = (var_58_133 ^ var_58_131);
    int32_t var_4c_112 = (var_58_131 | var_5c_98);
    int32_t var_5c_99 = (var_5c_98 ^ var_50_108);
    int32_t var_54_115 = ((var_54_113 | var_58_134) & var_4c_112);
    int32_t var_58_135 = (var_58_134 ^ var_5c_99);
    int32_t var_54_116 = (RORD(var_54_115, 0x13));
    int32_t var_50_109 = (RORD(var_50_108, 0x1d));
    int32_t var_58_139 = (RORD((var_50_109 ^ (((var_58_135 & var_54_115) ^ var_4c_112) ^ var_54_116)), 0x1f));
    int32_t var_5c_103 = (RORD(((((var_5c_99 & var_54_115) ^ var_58_135) ^ var_50_109) ^ (var_54_116 << 3)), 0x19));
    int32_t var_54_118 = (RORD((var_5c_103 ^ (var_54_116 ^ var_58_139)), 0x1b));
    int32_t var_50_111 = (RORD(((var_50_109 ^ var_5c_103) ^ (var_58_139 << 7)), 0xa));
    arg1[0xa] = var_54_118;
    arg1[4] = var_58_139;
    arg1[0xb] = var_50_111;
    arg1[5] = var_5c_103;
    int32_t var_54_119 = (var_54_118 ^ arg2[0x48]);
    int32_t var_58_140 = (var_58_139 ^ arg2[0x49]);
    int32_t var_50_112 = (var_50_111 ^ arg2[0x4a]);
    int32_t var_5c_104 = (var_5c_103 ^ arg2[0x4b]);
    int32_t var_54_121 = ((var_54_119 & var_50_112) ^ var_5c_104);
    int32_t var_50_114 = ((var_50_112 ^ var_58_140) ^ var_54_121);
    int32_t var_5c_106 = ((var_5c_104 | var_54_119) ^ var_58_140);
    int32_t var_4c_114 = (var_54_119 ^ var_50_114);
    int32_t var_5c_108 = ((var_5c_106 | var_4c_114) ^ var_54_121);
    int32_t var_4c_115 = (var_4c_114 ^ (var_54_121 & var_5c_106));
    int32_t var_50_115 = (RORD(var_50_114, 0x13));
    int32_t var_58_144 = (RORD(((var_5c_106 ^ var_5c_108) ^ var_4c_115), 0x1d));
    int32_t var_5c_110 = (RORD((var_58_144 ^ (var_5c_108 ^ var_50_115)), 0x1f));
    int32_t var_4c_118 = (RORD((((!var_4c_115) ^ var_58_144) ^ (var_50_115 << 3)), 0x19));
    int32_t var_50_118 = ((RORD((var_4c_118 ^ (var_50_115 ^ var_5c_110)), 0x1b)) ^ arg2[0x4c]);
    int32_t var_5c_111 = (var_5c_110 ^ arg2[0x4d]);
    int32_t var_58_147 = ((RORD(((var_58_144 ^ var_4c_118) ^ (var_5c_110 << 7)), 0xa)) ^ arg2[0x4e]);
    int32_t var_4c_119 = (var_4c_118 ^ arg2[0x4f]);
    int32_t var_50_119 = (var_50_118 | var_4c_119);
    int32_t var_4c_120 = (var_4c_119 ^ var_5c_111);
    int32_t var_5c_112 = (var_5c_111 & var_50_118);
    int32_t var_58_148 = (var_58_147 ^ var_4c_120);
    int32_t var_54_125 = ((var_50_118 ^ var_58_147) | var_5c_112);
    int32_t var_4c_122 = ((var_4c_120 & var_50_119) ^ var_54_125);
    int32_t var_50_120 = (var_50_119 ^ var_5c_112);
    int32_t var_5c_115 = (((var_5c_112 ^ var_4c_122) | var_50_120) ^ var_58_148);
    int32_t var_5c_118 = (RORD(((var_5c_115 | var_4c_122) ^ (var_50_120 ^ var_4c_122)), 0x13));
    int32_t var_4c_123 = (RORD(var_4c_122, 0x1d));
    int32_t var_58_151 = (RORD((var_4c_123 ^ (var_5c_115 ^ var_5c_118)), 0x1f));
    int32_t var_54_129 = (RORD(((((var_54_125 & var_50_120) ^ var_58_148) ^ var_4c_123) ^ (var_5c_118 << 3)), 0x19));
    int32_t var_5c_121 = ((RORD((var_54_129 ^ (var_5c_118 ^ var_58_151)), 0x1b)) ^ arg2[0x50]);
    int32_t var_54_130 = (var_54_129 ^ arg2[0x53]);
    int32_t var_58_153 = ((var_58_151 ^ arg2[0x51]) ^ var_54_130);
    int32_t var_54_131 = (!var_54_130);
    int32_t var_4c_127 = (((RORD(((var_4c_123 ^ var_54_129) ^ (var_58_151 << 7)), 0xa)) ^ arg2[0x52]) ^ var_54_131);
    int32_t var_54_132 = (var_54_131 ^ var_5c_121);
    int32_t var_58_155 = ((var_58_153 & var_54_132) ^ var_4c_127);
    int32_t var_50_123 = (var_58_153 ^ var_54_132);
    int32_t var_5c_122 = (var_5c_121 ^ var_50_123);
    int32_t var_4c_129 = ((var_4c_127 & var_50_123) ^ var_5c_122);
    int32_t var_5c_123 = (var_5c_122 & var_58_155);
    int32_t var_54_133 = (var_54_132 ^ var_5c_123);
    int32_t var_58_156 = (RORD(var_58_155, 0x13));
    int32_t var_5c_127 = (RORD((!((var_5c_123 | var_54_133) ^ var_4c_129)), 0x1d));
    int32_t var_50_128 = (RORD((var_5c_127 ^ ((((var_50_123 | var_58_155) ^ var_5c_123) ^ (var_4c_129 & var_54_133)) ^ var_58_156)), 0x1f));
    int32_t var_54_135 = (RORD(((var_54_133 ^ var_5c_127) ^ (var_58_156 << 3)), 0x19));
    int32_t var_50_129 = (var_50_128 ^ arg2[0x55]);
    int32_t var_54_136 = (var_54_135 ^ arg2[0x57]);
    int32_t var_58_160 = (((RORD((var_54_135 ^ (var_58_156 ^ var_50_128)), 0x1b)) ^ arg2[0x54]) ^ var_50_129);
    int32_t var_50_130 = (var_50_129 ^ var_54_136);
    int32_t var_54_137 = (!var_54_136);
    int32_t var_5c_131 = (((RORD(((var_5c_127 ^ var_54_135) ^ (var_50_128 << 7)), 0xa)) ^ arg2[0x56]) ^ var_54_137);
    int32_t var_50_132 = ((var_50_130 & var_58_160) ^ var_5c_131);
    int32_t var_5c_132 = (var_5c_131 | var_50_130);
    int32_t var_54_139 = ((var_54_137 & var_50_132) ^ var_58_160);
    int32_t var_4c_134 = (((var_50_130 ^ var_54_137) ^ var_50_132) ^ var_5c_132);
    int32_t var_50_133 = (RORD(var_50_132, 0x13));
    int32_t var_58_163 = (RORD(((var_58_160 & var_54_139) ^ var_4c_134), 0x1d));
    int32_t var_54_141 = (RORD((var_58_163 ^ (var_54_139 ^ var_50_133)), 0x1f));
    int32_t var_5c_137 = (RORD(((((!(var_5c_132 ^ var_58_160)) ^ (var_4c_134 | var_54_139)) ^ var_58_163) ^ (var_50_133 << 3)), 0x19));
    int32_t var_50_136 = ((RORD((var_5c_137 ^ (var_50_133 ^ var_54_141)), 0x1b)) ^ arg2[0x58]);
    int32_t var_5c_138 = (var_5c_137 ^ arg2[0x5b]);
    int32_t var_58_167 = (!((RORD(((var_58_163 ^ var_5c_137) ^ (var_54_141 << 7)), 0xa)) ^ arg2[0x5a]));
    int32_t var_50_137 = (var_50_136 ^ var_5c_138);
    int32_t var_5c_140 = ((var_5c_138 & var_50_136) ^ var_58_167);
    int32_t var_54_143 = ((var_54_141 ^ arg2[0x59]) ^ var_5c_140);
    int32_t var_50_138 = (var_50_137 | var_54_143);
    int32_t var_58_170 = (((var_58_167 | var_5c_138) ^ var_50_137) ^ var_54_143);
    int32_t var_50_140 = ((var_50_138 | var_5c_140) ^ var_58_170);
    int32_t var_4c_139 = (((var_5c_138 ^ var_50_138) ^ var_5c_140) ^ var_50_140);
    int32_t var_50_141 = (RORD(var_50_140, 0x13));
    int32_t var_4c_140 = (RORD(var_4c_139, 0x1d));
    int32_t var_54_145 = (RORD((var_4c_140 ^ (var_54_143 ^ var_50_141)), 0x1f));
    int32_t var_58_174 = (RORD(((((var_58_170 & var_4c_139) ^ (!var_5c_140)) ^ var_4c_140) ^ (var_50_141 << 3)), 0x19));
    int32_t var_50_144 = ((RORD((var_58_174 ^ (var_50_141 ^ var_54_145)), 0x1b)) ^ arg2[0x5c]);
    int32_t var_54_146 = (var_54_145 ^ arg2[0x5d]);
    int32_t var_4c_143 = ((RORD(((var_4c_140 ^ var_58_174) ^ (var_54_145 << 7)), 0xa)) ^ arg2[0x5e]);
    int32_t var_58_175 = (var_58_174 ^ arg2[0x5f]);
    int32_t var_54_148 = ((var_54_146 | var_4c_143) ^ var_58_175);
    int32_t var_5c_143 = (var_54_146 ^ var_4c_143);
    int32_t var_4c_144 = (var_4c_143 ^ var_54_148);
    int32_t var_5c_144 = (var_5c_143 ^ var_4c_144);
    int32_t var_50_146 = ((var_50_144 | var_5c_144) ^ var_4c_144);
    int32_t var_54_151 = (((var_54_148 | var_5c_144) ^ var_50_144) ^ var_5c_144);
    int32_t var_5c_146 = (RORD((var_5c_144 ^ ((!(var_4c_144 ^ var_54_151)) | var_50_146)), 0x13));
    int32_t var_54_154 = (RORD(((var_54_151 & var_50_146) ^ var_5c_144), 0x1d));
    int32_t var_58_180 = (RORD((var_54_154 ^ ((((var_58_175 | var_5c_143) & var_50_144) ^ var_54_148) ^ var_5c_146)), 0x1f));
    int32_t var_50_148 = (RORD(((var_50_146 ^ var_54_154) ^ (var_5c_146 << 3)), 0x19));
    int32_t var_58_181 = (var_58_180 ^ arg2[0x61]);
    int32_t var_54_157 = ((RORD(((var_54_154 ^ var_50_148) ^ (var_58_180 << 7)), 0xa)) ^ arg2[0x62]);
    int32_t var_50_149 = (var_50_148 ^ arg2[0x63]);
    arg1[3] = ((RORD((var_50_148 ^ (var_5c_146 ^ var_58_180)), 0x1b)) ^ arg2[0x60]);
    arg1[2] = var_58_181;
    arg1[1] = var_54_157;
    *arg1 = var_50_149;
    arg1[0x20] = 0x50;
    int64_t rax_559 = (rax ^ *(fsbase + 0x28));
    if (rax_559 == 0)
    {
        return rax_559;
    }
    __stack_chk_fail();
    /* no return */
}

uint64_t sosemanuk_internal(int32_t* arg1)
{
    int32_t rax_1 = *arg1;
    int32_t rax_3 = arg1[1];
    int32_t rax_5 = arg1[2];
    int32_t rax_7 = arg1[3];
    int32_t rax_9 = arg1[4];
    int32_t rax_11 = arg1[5];
    int32_t rax_13 = arg1[6];
    int32_t rax_15 = arg1[7];
    int32_t rax_17 = arg1[8];
    int32_t rax_19 = arg1[9];
    int32_t rax_21 = arg1[0xa];
    int32_t rax_23 = arg1[0xb];
    int32_t var_160;
    if ((rax_21 & 1) == 0)
    {
        var_160 = rax_3;
    }
    else
    {
        var_160 = (rax_3 ^ rax_17);
    }
    int32_t rax_30 = (var_160 + rax_23);
    int32_t rax_34 = (RORD((rax_21 * 0x54655307), 0x19));
    int32_t rax_47 = (((*((rax_7 << 2) + 0x6096e0) ^ (rax_7 >> 8)) ^ ((rax_1 << 8) ^ *(((rax_1 >> 0x18) << 2) + 0x6092e0))) ^ rax_19);
    int32_t rax_50 = ((rax_30 + rax_19) ^ rax_34);
    int32_t var_15c;
    if ((rax_30 & 1) == 0)
    {
        var_15c = rax_5;
    }
    else
    {
        var_15c = (rax_5 ^ rax_19);
    }
    int32_t rax_57 = (var_15c + rax_34);
    int32_t rax_61 = (RORD((rax_30 * 0x54655307), 0x19));
    int32_t rax_74 = (((*((rax_9 << 2) + 0x6096e0) ^ (rax_9 >> 8)) ^ ((rax_3 << 8) ^ *(((rax_3 >> 0x18) << 2) + 0x6092e0))) ^ rax_47);
    int32_t rax_77 = ((rax_57 + rax_47) ^ rax_61);
    int32_t var_158;
    if ((rax_57 & 1) == 0)
    {
        var_158 = rax_7;
    }
    else
    {
        var_158 = (rax_7 ^ rax_47);
    }
    int32_t rax_84 = (var_158 + rax_61);
    int32_t rax_88 = (RORD((rax_57 * 0x54655307), 0x19));
    int32_t rax_101 = (((*((rax_11 << 2) + 0x6096e0) ^ (rax_11 >> 8)) ^ ((rax_5 << 8) ^ *(((rax_5 >> 0x18) << 2) + 0x6092e0))) ^ rax_74);
    int32_t rax_104 = ((rax_84 + rax_74) ^ rax_88);
    int32_t var_154;
    if ((rax_84 & 1) == 0)
    {
        var_154 = rax_9;
    }
    else
    {
        var_154 = (rax_9 ^ rax_74);
    }
    int32_t rax_111 = (var_154 + rax_88);
    int32_t rax_115 = (RORD((rax_84 * 0x54655307), 0x19));
    int32_t rax_128 = (((*((rax_13 << 2) + 0x6096e0) ^ (rax_13 >> 8)) ^ ((rax_7 << 8) ^ *(((rax_7 >> 0x18) << 2) + 0x6092e0))) ^ rax_101);
    int32_t rax_131 = ((rax_111 + rax_101) ^ rax_115);
    int32_t var_3c_2 = ((rax_50 & rax_104) ^ rax_131);
    int32_t var_44_2 = ((rax_104 ^ rax_77) ^ var_3c_2);
    int32_t var_48_2 = ((rax_131 | rax_50) ^ rax_77);
    int32_t var_4c_1 = (rax_50 ^ var_44_2);
    int32_t var_48_4 = ((var_48_2 | var_4c_1) ^ var_3c_2);
    int32_t var_4c_2 = (var_4c_1 ^ (var_3c_2 & var_48_2));
    encode32le(&arg1[0xc], (var_44_2 ^ rax_1));
    encode32le(&arg1[0xd], (var_48_4 ^ rax_3));
    encode32le(&arg1[0xe], (((var_48_2 ^ var_48_4) ^ var_4c_2) ^ rax_5));
    encode32le(&arg1[0xf], ((!var_4c_2) ^ rax_7));
    int32_t var_150;
    if ((rax_111 & 1) == 0)
    {
        var_150 = rax_11;
    }
    else
    {
        var_150 = (rax_11 ^ rax_101);
    }
    int32_t rax_163 = (var_150 + rax_115);
    int32_t rax_167 = (RORD((rax_111 * 0x54655307), 0x19));
    int32_t rax_180 = (((*((rax_15 << 2) + 0x6096e0) ^ (rax_15 >> 8)) ^ ((rax_9 << 8) ^ *(((rax_9 >> 0x18) << 2) + 0x6092e0))) ^ rax_128);
    int32_t rax_183 = ((rax_163 + rax_128) ^ rax_167);
    int32_t var_14c;
    if ((rax_163 & 1) == 0)
    {
        var_14c = rax_13;
    }
    else
    {
        var_14c = (rax_13 ^ rax_128);
    }
    int32_t rax_190 = (var_14c + rax_167);
    int32_t rax_194 = (RORD((rax_163 * 0x54655307), 0x19));
    int32_t rax_207 = (((*((rax_17 << 2) + 0x6096e0) ^ (rax_17 >> 8)) ^ ((rax_11 << 8) ^ *(((rax_11 >> 0x18) << 2) + 0x6092e0))) ^ rax_180);
    int32_t rax_210 = ((rax_190 + rax_180) ^ rax_194);
    int32_t var_148;
    if ((rax_190 & 1) == 0)
    {
        var_148 = rax_15;
    }
    else
    {
        var_148 = (rax_15 ^ rax_180);
    }
    int32_t rax_217 = (var_148 + rax_194);
    int32_t rax_221 = (RORD((rax_190 * 0x54655307), 0x19));
    int32_t rax_234 = (((*((rax_19 << 2) + 0x6096e0) ^ (rax_19 >> 8)) ^ ((rax_13 << 8) ^ *(((rax_13 >> 0x18) << 2) + 0x6092e0))) ^ rax_207);
    int32_t rax_237 = ((rax_217 + rax_207) ^ rax_221);
    int32_t var_144;
    if ((rax_217 & 1) == 0)
    {
        var_144 = rax_17;
    }
    else
    {
        var_144 = (rax_17 ^ rax_207);
    }
    int32_t rax_244 = (var_144 + rax_221);
    int32_t rax_248 = (RORD((rax_217 * 0x54655307), 0x19));
    int32_t rax_261 = (((*((rax_47 << 2) + 0x6096e0) ^ (rax_47 >> 8)) ^ ((rax_15 << 8) ^ *(((rax_15 >> 0x18) << 2) + 0x6092e0))) ^ rax_234);
    int32_t rax_264 = ((rax_244 + rax_234) ^ rax_248);
    int32_t var_3c_6 = ((rax_183 & rax_237) ^ rax_264);
    int32_t var_44_5 = ((rax_237 ^ rax_210) ^ var_3c_6);
    int32_t var_48_7 = ((rax_264 | rax_183) ^ rax_210);
    int32_t var_4c_5 = (rax_183 ^ var_44_5);
    int32_t var_48_9 = ((var_48_7 | var_4c_5) ^ var_3c_6);
    int32_t var_4c_6 = (var_4c_5 ^ (var_3c_6 & var_48_7));
    encode32le(&arg1[0x10], (var_44_5 ^ rax_9));
    encode32le(&arg1[0x11], (var_48_9 ^ rax_11));
    encode32le(&arg1[0x12], (((var_48_7 ^ var_48_9) ^ var_4c_6) ^ rax_13));
    encode32le(&arg1[0x13], ((!var_4c_6) ^ rax_15));
    int32_t var_140;
    if ((rax_244 & 1) == 0)
    {
        var_140 = rax_19;
    }
    else
    {
        var_140 = (rax_19 ^ rax_234);
    }
    int32_t rax_298 = (var_140 + rax_248);
    int32_t rax_302 = (RORD((rax_244 * 0x54655307), 0x19));
    int32_t rax_315 = (((*((rax_74 << 2) + 0x6096e0) ^ (rax_74 >> 8)) ^ ((rax_17 << 8) ^ *(((rax_17 >> 0x18) << 2) + 0x6092e0))) ^ rax_261);
    int32_t rax_318 = ((rax_298 + rax_261) ^ rax_302);
    int32_t var_13c;
    if ((rax_298 & 1) == 0)
    {
        var_13c = rax_47;
    }
    else
    {
        var_13c = (rax_47 ^ rax_261);
    }
    int32_t rax_325 = (var_13c + rax_302);
    int32_t rax_329 = (RORD((rax_298 * 0x54655307), 0x19));
    int32_t rax_342 = (((*((rax_101 << 2) + 0x6096e0) ^ (rax_101 >> 8)) ^ ((rax_19 << 8) ^ *(((rax_19 >> 0x18) << 2) + 0x6092e0))) ^ rax_315);
    int32_t rax_345 = ((rax_325 + rax_315) ^ rax_329);
    int32_t var_138;
    if ((rax_325 & 1) == 0)
    {
        var_138 = rax_74;
    }
    else
    {
        var_138 = (rax_74 ^ rax_315);
    }
    int32_t rax_352 = (var_138 + rax_329);
    int32_t rax_356 = (RORD((rax_325 * 0x54655307), 0x19));
    int32_t rax_369 = (((*((rax_128 << 2) + 0x6096e0) ^ (rax_128 >> 8)) ^ ((rax_47 << 8) ^ *(((rax_47 >> 0x18) << 2) + 0x6092e0))) ^ rax_342);
    int32_t rax_372 = ((rax_352 + rax_342) ^ rax_356);
    int32_t var_134;
    if ((rax_352 & 1) == 0)
    {
        var_134 = rax_101;
    }
    else
    {
        var_134 = (rax_101 ^ rax_342);
    }
    int32_t rax_379 = (var_134 + rax_356);
    int32_t rax_383 = (RORD((rax_352 * 0x54655307), 0x19));
    int32_t rax_396 = (((*((rax_180 << 2) + 0x6096e0) ^ (rax_180 >> 8)) ^ ((rax_74 << 8) ^ *(((rax_74 >> 0x18) << 2) + 0x6092e0))) ^ rax_369);
    int32_t rax_399 = ((rax_379 + rax_369) ^ rax_383);
    int32_t var_3c_10 = ((rax_318 & rax_372) ^ rax_399);
    int32_t var_44_8 = ((rax_372 ^ rax_345) ^ var_3c_10);
    int32_t var_48_12 = ((rax_399 | rax_318) ^ rax_345);
    int32_t var_4c_9 = (rax_318 ^ var_44_8);
    int32_t var_48_14 = ((var_48_12 | var_4c_9) ^ var_3c_10);
    int32_t var_4c_10 = (var_4c_9 ^ (var_3c_10 & var_48_12));
    encode32le(&arg1[0x14], (var_44_8 ^ rax_17));
    encode32le(&arg1[0x15], (var_48_14 ^ rax_19));
    encode32le(&arg1[0x16], (((var_48_12 ^ var_48_14) ^ var_4c_10) ^ rax_47));
    encode32le(&arg1[0x17], ((!var_4c_10) ^ rax_74));
    int32_t var_130;
    if ((rax_379 & 1) == 0)
    {
        var_130 = rax_128;
    }
    else
    {
        var_130 = (rax_128 ^ rax_369);
    }
    int32_t rax_433 = (var_130 + rax_383);
    int32_t rax_437 = (RORD((rax_379 * 0x54655307), 0x19));
    int32_t rax_450 = (((*((rax_207 << 2) + 0x6096e0) ^ (rax_207 >> 8)) ^ ((rax_101 << 8) ^ *(((rax_101 >> 0x18) << 2) + 0x6092e0))) ^ rax_396);
    int32_t rax_453 = ((rax_433 + rax_396) ^ rax_437);
    int32_t var_12c;
    if ((rax_433 & 1) == 0)
    {
        var_12c = rax_180;
    }
    else
    {
        var_12c = (rax_180 ^ rax_396);
    }
    int32_t rax_460 = (var_12c + rax_437);
    int32_t rax_464 = (RORD((rax_433 * 0x54655307), 0x19));
    int32_t rax_477 = (((*((rax_234 << 2) + 0x6096e0) ^ (rax_234 >> 8)) ^ ((rax_128 << 8) ^ *(((rax_128 >> 0x18) << 2) + 0x6092e0))) ^ rax_450);
    int32_t rax_480 = ((rax_460 + rax_450) ^ rax_464);
    int32_t var_128;
    if ((rax_460 & 1) == 0)
    {
        var_128 = rax_207;
    }
    else
    {
        var_128 = (rax_207 ^ rax_450);
    }
    int32_t rax_487 = (var_128 + rax_464);
    int32_t rax_491 = (RORD((rax_460 * 0x54655307), 0x19));
    int32_t rax_504 = (((*((rax_261 << 2) + 0x6096e0) ^ (rax_261 >> 8)) ^ ((rax_180 << 8) ^ *(((rax_180 >> 0x18) << 2) + 0x6092e0))) ^ rax_477);
    int32_t rax_507 = ((rax_487 + rax_477) ^ rax_491);
    int32_t var_124;
    if ((rax_487 & 1) == 0)
    {
        var_124 = rax_234;
    }
    else
    {
        var_124 = (rax_234 ^ rax_477);
    }
    int32_t rax_514 = (var_124 + rax_491);
    int32_t rax_518 = (RORD((rax_487 * 0x54655307), 0x19));
    int32_t rax_531 = (((*((rax_315 << 2) + 0x6096e0) ^ (rax_315 >> 8)) ^ ((rax_207 << 8) ^ *(((rax_207 >> 0x18) << 2) + 0x6092e0))) ^ rax_504);
    int32_t rax_534 = ((rax_514 + rax_504) ^ rax_518);
    int32_t var_3c_14 = ((rax_453 & rax_507) ^ rax_534);
    int32_t var_44_11 = ((rax_507 ^ rax_480) ^ var_3c_14);
    int32_t var_48_17 = ((rax_534 | rax_453) ^ rax_480);
    int32_t var_4c_13 = (rax_453 ^ var_44_11);
    int32_t var_48_19 = ((var_48_17 | var_4c_13) ^ var_3c_14);
    int32_t var_4c_14 = (var_4c_13 ^ (var_3c_14 & var_48_17));
    encode32le(&arg1[0x18], (var_44_11 ^ rax_101));
    encode32le(&arg1[0x19], (var_48_19 ^ rax_128));
    encode32le(&arg1[0x1a], (((var_48_17 ^ var_48_19) ^ var_4c_14) ^ rax_180));
    encode32le(&arg1[0x1b], ((!var_4c_14) ^ rax_207));
    int32_t var_120;
    if ((rax_514 & 1) == 0)
    {
        var_120 = rax_261;
    }
    else
    {
        var_120 = (rax_261 ^ rax_504);
    }
    int32_t rax_568 = (var_120 + rax_518);
    int32_t rax_572 = (RORD((rax_514 * 0x54655307), 0x19));
    int32_t rax_585 = (((*((rax_342 << 2) + 0x6096e0) ^ (rax_342 >> 8)) ^ ((rax_234 << 8) ^ *(((rax_234 >> 0x18) << 2) + 0x6092e0))) ^ rax_531);
    int32_t rax_588 = ((rax_568 + rax_531) ^ rax_572);
    int32_t var_11c;
    if ((rax_568 & 1) == 0)
    {
        var_11c = rax_315;
    }
    else
    {
        var_11c = (rax_315 ^ rax_531);
    }
    int32_t rax_595 = (var_11c + rax_572);
    int32_t rax_599 = (RORD((rax_568 * 0x54655307), 0x19));
    int32_t rax_612 = (((*((rax_369 << 2) + 0x6096e0) ^ (rax_369 >> 8)) ^ ((rax_261 << 8) ^ *(((rax_261 >> 0x18) << 2) + 0x6092e0))) ^ rax_585);
    int32_t rax_615 = ((rax_595 + rax_585) ^ rax_599);
    int32_t var_118;
    if ((rax_595 & 1) == 0)
    {
        var_118 = rax_342;
    }
    else
    {
        var_118 = (rax_342 ^ rax_585);
    }
    int32_t rax_622 = (var_118 + rax_599);
    int32_t rax_626 = (RORD((rax_595 * 0x54655307), 0x19));
    int32_t rax_639 = (((*((rax_396 << 2) + 0x6096e0) ^ (rax_396 >> 8)) ^ ((rax_315 << 8) ^ *(((rax_315 >> 0x18) << 2) + 0x6092e0))) ^ rax_612);
    int32_t rax_642 = ((rax_622 + rax_612) ^ rax_626);
    int32_t var_114;
    if ((rax_622 & 1) == 0)
    {
        var_114 = rax_369;
    }
    else
    {
        var_114 = (rax_369 ^ rax_612);
    }
    int32_t rax_649 = (var_114 + rax_626);
    int32_t rax_653 = (RORD((rax_622 * 0x54655307), 0x19));
    int32_t rax_666 = (((*((rax_450 << 2) + 0x6096e0) ^ (rax_450 >> 8)) ^ ((rax_342 << 8) ^ *(((rax_342 >> 0x18) << 2) + 0x6092e0))) ^ rax_639);
    int32_t rax_669 = ((rax_649 + rax_639) ^ rax_653);
    int32_t var_3c_18 = ((rax_588 & rax_642) ^ rax_669);
    int32_t var_44_14 = ((rax_642 ^ rax_615) ^ var_3c_18);
    int32_t var_48_22 = ((rax_669 | rax_588) ^ rax_615);
    int32_t var_4c_17 = (rax_588 ^ var_44_14);
    int32_t var_48_24 = ((var_48_22 | var_4c_17) ^ var_3c_18);
    int32_t var_4c_18 = (var_4c_17 ^ (var_3c_18 & var_48_22));
    encode32le(&arg1[0x1c], (var_44_14 ^ rax_234));
    encode32le(&arg1[0x1d], (var_48_24 ^ rax_261));
    encode32le(&arg1[0x1e], (((var_48_22 ^ var_48_24) ^ var_4c_18) ^ rax_315));
    encode32le(&arg1[0x1f], ((!var_4c_18) ^ rax_342));
    *arg1 = rax_369;
    arg1[1] = rax_396;
    arg1[2] = rax_450;
    arg1[3] = rax_477;
    arg1[4] = rax_504;
    arg1[5] = rax_531;
    arg1[6] = rax_585;
    arg1[7] = rax_612;
    arg1[8] = rax_639;
    arg1[9] = rax_666;
    arg1[0xa] = rax_649;
    uint64_t rax_708 = rax_653;
    arg1[0xb] = rax_708;
    return rax_708;
}

uint64_t encode32le(char* arg1, int32_t arg2)
{
    *arg1 = arg2;
    arg1[1] = (arg2 >> 8);
    arg1[2] = (arg2 >> 0x10);
    uint64_t rax_7 = (arg2 >> 0x18);
    arg1[3] = rax_7;
    return rax_7;
}

uint64_t sosemanuk_prng(uint64_t arg1, int64_t arg2, uint64_t arg3)
{
    int64_t var_28 = arg2;
    uint64_t var_30 = arg3;
    uint64_t rax_1 = *(arg1 + 0x80);
    if (rax_1 <= 0x4f)
    {
        uint64_t var_10_1 = (0x50 - *(arg1 + 0x80));
        if (var_10_1 > var_30)
        {
            var_10_1 = var_30;
        }
        memcpy(var_28, ((arg1 + 0x30) + *(arg1 + 0x80)), var_10_1);
        var_28 = (var_28 + var_10_1);
        var_30 = (var_30 - var_10_1);
        rax_1 = arg1;
        *(rax_1 + 0x80) = (*(arg1 + 0x80) + var_10_1);
    }
    while (var_30 != 0)
    {
        sosemanuk_internal(arg1);
        if (var_30 <= 0x4f)
        {
            memcpy(var_28, (arg1 + 0x30), var_30);
            rax_1 = arg1;
            *(rax_1 + 0x80) = var_30;
            var_30 = 0;
        }
        else
        {
            rax_1 = memcpy(var_28, (arg1 + 0x30), 0x50);
            var_28 = (var_28 + 0x50);
            var_30 = (var_30 - 0x50);
        }
    }
    return rax_1;
}

uint64_t sosemanuk_encrypt(uint64_t arg1, char* arg2, char* arg3, int64_t arg4)
{
    char* var_28 = arg2;
    char* var_30 = arg3;
    int64_t var_38 = arg4;
    uint64_t rax_1 = *(arg1 + 0x80);
    if (rax_1 <= 0x4f)
    {
        int64_t var_10_1 = (0x50 - *(arg1 + 0x80));
        if (var_10_1 > var_38)
        {
            var_10_1 = var_38;
        }
        xorbuf(((arg1 + 0x30) + *(arg1 + 0x80)), var_28, var_30, var_10_1);
        var_28 = &var_28[var_10_1];
        var_30 = &var_30[var_10_1];
        var_38 = (var_38 - var_10_1);
        rax_1 = arg1;
        *(rax_1 + 0x80) = (*(arg1 + 0x80) + var_10_1);
    }
    while (var_38 != 0)
    {
        sosemanuk_internal(arg1);
        if (var_38 <= 0x4f)
        {
            xorbuf((arg1 + 0x30), var_28, var_30, var_38);
            rax_1 = arg1;
            *(rax_1 + 0x80) = var_38;
            var_38 = 0;
        }
        else
        {
            rax_1 = xorbuf((arg1 + 0x30), var_28, var_30, 0x50);
            var_28 = &var_28[0x50];
            var_30 = &var_30[0x50];
            var_38 = (var_38 - 0x50);
        }
    }
    return rax_1;
}

void xorbuf(char* arg1, char* arg2, char* arg3, int64_t arg4)
{
    char* var_10 = arg1;
    char* var_18 = arg2;
    char* var_20 = arg3;
    int64_t var_28 = arg4;
    while (true)
    {
        var_28 = (var_28 - 1);
        if (var_28 == -1)
        {
            break;
        }
        *var_20 = (*var_10 ^ *var_18);
        var_20 = &var_20[1];
        var_10 = &var_10[1];
        var_18 = &var_18[1];
    }
}

void __libc_csu_fini()
{
    return;
}

void __libc_csu_init()
{
    _init();
}

int64_t __do_global_ctors_aux()
{
    return -1;
}

int64_t _fini()
{
    return __do_global_dtors_aux();
}