LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/an4[P]Applied-Security-Mod/modmul.c
// Function: getSeed
void getSeed(gmp_randstate_t state) {
    // get value from /dev/urandom
    unsigned int data[40];
    FILE* file;
    file = fopen("/dev/random", "r");

    int b = fread(&data, 40, sizeof(unsigned int), file);
    fclose(file);

    if(b != sizeof(unsigned int)) {
        fputs ("Reading error",stderr);
        exit (3);
    }

    // assign seed
    mpz_t seed;
    mpz_init(seed);
    mpz_import(seed, 40, 1, sizeof(data[0]), 0, 0, data);

    // seed
    gmp_randseed(state, seed);
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
leaq 0x34312(%rip), %rdi     # 0x37008
leaq 0x34323(%rip), %rsi     # 0x37020
callq 0x2170
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rcx
leaq 0x30(%rsp), %rdi
movl $0x28, %esi
movl $0x4, %edx
callq 0x2070
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2080
movslq 0x24(%rsp), %rax
cmpq $0x4, %rax
je 0x2d59
movq 0x3e2b0(%rip), %rax     # 0x40ff0
movq (%rax), %rsi
leaq 0x342ca(%rip), %rdi     # 0x37014
callq 0x20d0
movl $0x3, %edi
callq 0x2190
leaq 0x10(%rsp), %rdi
callq 0x4a80
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rax
movl $0x28, %esi
movl $0x1, %edx
movl $0x4, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
movq %rax, (%rsp)
callq 0x4690
movq 0xd0(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x210f0
addq $0xd8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/an4[P]Applied-Security-Mod/modmul.c
// Function: CRT_first
void CRT_first(mpz_t c,
               mpz_t i_q,
               mpz_t i_p,
               mpz_t d_q,
               mpz_t d_p,
               mpz_t q,
               mpz_t p,
               mpz_t d,
               mpz_t N,
               mpz_t m) {

     mpz_t m_p;
     mpz_t m_q;
     mpz_init(m_p);
     mpz_init(m_q);

     mpz_powm(m_p, c, d_p, p);
     mpz_powm(m_q, c, d_q, q);

     mpz_mul(m_p, m_p, q);
     mpz_mod(m_p, m_p, N);

     mpz_mul(m_p, m_p, i_q);
     mpz_mod(m_p, m_p, N);

     mpz_mul(m_q, m_q, p);
     mpz_mod(m_q, m_q, N);

     mpz_mul(m_q, m_q, i_p);
     mpz_mod(m_q, m_q, N);

     mpz_add(m, m_p, m_q);
     mpz_mod(m, m, N);

     mpz_clear(m_p);
     mpz_clear(m_q);
}

// Assembly:
subq $0x58, %rsp
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x4a80
movq %rsp, %rdi
callq 0x4a80
leaq 0x10(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x60(%rsp), %rcx
callq 0x5460
movq %rsp, %rdi
movq 0x50(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x5460
leaq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x4ed0
leaq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x4d60
leaq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x4ed0
leaq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x4d60
movq %rsp, %rdi
movq %rsp, %rsi
movq 0x60(%rsp), %rdx
callq 0x4ed0
movq %rsp, %rdi
movq %rsp, %rsi
movq 0x70(%rsp), %rdx
callq 0x4d60
movq %rsp, %rdi
movq %rsp, %rsi
movq 0x40(%rsp), %rdx
callq 0x4ed0
movq %rsp, %rdi
movq %rsp, %rsi
movq 0x70(%rsp), %rdx
callq 0x4d60
movq 0x78(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rsp, %rdx
callq 0x40c0
movq 0x78(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x4d60
leaq 0x10(%rsp), %rdi
callq 0x4460
movq %rsp, %rdi
callq 0x4460
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/an4[P]Applied-Security-Mod/modmul.c
// Function: stage1
void stage1() {
      // fill in this function with solution
    mpz_t N, e, m, c;

    while(!feof(stdin)) {
        initialize_and_read(N);
        initialize_and_read(e);
        initialize_and_read(m);

        if(mpz_cmp_ui(N, 0) == 0) {
            return;
        }

        mpz_init( c );

        sliding_window_exponentiation(c, m, e, N);

        gmp_printf( "%Zx\n", c );

        mpz_clear( N );
        mpz_clear( e );
        mpz_clear( m );
        mpz_clear( c );
      }
}

// Assembly:
subq $0x58, %rsp
movq 0x3dd45(%rip), %rax     # 0x40fd0
movq (%rax), %rdi
callq 0x2100
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x32a4
jmp 0x3353
leaq 0x40(%rsp), %rdi
callq 0x22f0
leaq 0x30(%rsp), %rdi
callq 0x22f0
leaq 0x20(%rsp), %rdi
callq 0x22f0
cmpl $0x0, 0x44(%rsp)
jge 0x32d4
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0xc(%rsp)
jmp 0x32e5
cmpl $0x0, 0x44(%rsp)
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl $0x0, %eax
jne 0x32f0
jmp 0x3353
leaq 0x10(%rsp), %rdi
callq 0x4a80
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x40(%rsp), %rcx
callq 0x23a0
leaq 0x10(%rsp), %rsi
leaq 0x33d03(%rip), %rdi     # 0x37022
movb $0x0, %al
callq 0x20ba0
leaq 0x40(%rsp), %rdi
callq 0x4460
leaq 0x30(%rsp), %rdi
callq 0x4460
leaq 0x20(%rsp), %rdi
callq 0x4460
leaq 0x10(%rsp), %rdi
callq 0x4460
jmp 0x3284
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/an4[P]Applied-Security-Mod/modmul.c
// Function: stage2
void stage2() {
    // fill in this function with solution
    mpz_t N, d, p, q, d_p, d_q, i_p, i_q, c, m;

    while(!feof(stdin)) {
        initialize_and_read(N);
        initialize_and_read(d);
        initialize_and_read(p);
        initialize_and_read(q);
        initialize_and_read(d_p);
        initialize_and_read(d_q);
        initialize_and_read(i_p);
        initialize_and_read(i_q);
        initialize_and_read(c);

        if(mpz_cmp_ui(N, 0) == 0) {
            return;
        }

        mpz_init(m);

        // mpz_powm(m, c, d, N);

        // CRT modular exponentiation

        CRT(c, i_q, i_p, d_q, d_p, q, p, d, N, m);

        gmp_printf( "%Zx\n", m );

        mpz_clear(N);
        mpz_clear(d);
        mpz_clear(p);
        mpz_clear(q);
        mpz_clear(d_p);
        mpz_clear(d_q);
        mpz_clear(i_p);
        mpz_clear(i_q);
        mpz_clear(c);
    }
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq 0x3dc61(%rip), %rax     # 0x40fd0
movq (%rax), %rdi
callq 0x2100
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3388
jmp 0x350c
leaq 0xc0(%rsp), %rdi
callq 0x22f0
leaq 0xb0(%rsp), %rdi
callq 0x22f0
leaq 0xa0(%rsp), %rdi
callq 0x22f0
leaq 0x90(%rsp), %rdi
callq 0x22f0
leaq 0x80(%rsp), %rdi
callq 0x22f0
leaq 0x70(%rsp), %rdi
callq 0x22f0
leaq 0x60(%rsp), %rdi
callq 0x22f0
leaq 0x50(%rsp), %rdi
callq 0x22f0
leaq 0x40(%rsp), %rdi
callq 0x22f0
cmpl $0x0, 0xc4(%rsp)
jge 0x3406
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x2c(%rsp)
jmp 0x341a
cmpl $0x0, 0xc4(%rsp)
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl $0x0, %eax
jne 0x3428
jmp 0x350c
leaq 0x30(%rsp), %rdi
callq 0x4a80
leaq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x60(%rsp), %rdx
leaq 0x70(%rsp), %rcx
leaq 0x80(%rsp), %r8
leaq 0x90(%rsp), %r9
leaq 0xa0(%rsp), %rbx
leaq 0xb0(%rsp), %r11
leaq 0xc0(%rsp), %r10
leaq 0x30(%rsp), %rax
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x2db0
leaq 0x30(%rsp), %rsi
leaq 0x33b8b(%rip), %rdi     # 0x37022
movb $0x0, %al
callq 0x20ba0
leaq 0xc0(%rsp), %rdi
callq 0x4460
leaq 0xb0(%rsp), %rdi
callq 0x4460
leaq 0xa0(%rsp), %rdi
callq 0x4460
leaq 0x90(%rsp), %rdi
callq 0x4460
leaq 0x80(%rsp), %rdi
callq 0x4460
leaq 0x70(%rsp), %rdi
callq 0x4460
leaq 0x60(%rsp), %rdi
callq 0x4460
leaq 0x50(%rsp), %rdi
callq 0x4460
leaq 0x40(%rsp), %rdi
callq 0x4460
jmp 0x3368
addq $0xd0, %rsp
popq %rbx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/an4[P]Applied-Security-Mod/modmul.c
// Function: stage3
void stage3() {
    // fill in this function with solution
    mpz_t p, q, g, h, m, c1, c2, k;

    // State
    gmp_randstate_t state;
    gmp_randinit_default(state);

    getSeed(state);

    while(!feof(stdin)) {
        initialize_and_read(p);
        initialize_and_read(q);
        initialize_and_read(g);
        initialize_and_read(h);
        initialize_and_read(m);

        if(mpz_cmp_ui(p, 0) == 0) {
            return;
        }

        mpz_init(c1);
        mpz_init(c2);
        mpz_init(k);
        mpz_set_ui(k, 0);

        // Random
        while(mpz_cmp_ui(k, 0) == 0){
            mpz_urandomm(k, state, q);
        }

        // mpz_powm(c1, g, k, p);
        sliding_window_exponentiation(c1, g, k, p);

        //mpz_powm(h, h, k, p);
        sliding_window_exponentiation(h, h, k, p);

        // mpz_mul(c2, m, h);
        // mpz_mod(c2, c2, p);
        montgomery(c2, m, h, p);

        gmp_printf( "%Zx\n", c1 );
        gmp_printf( "%Zx\n", c2 );

        mpz_clear(p);
        mpz_clear(q);
        mpz_clear(g);
        mpz_clear(h);
        mpz_clear(m);
    }
}

// Assembly:
subq $0xb8, %rsp
leaq 0x10(%rsp), %rdi
callq 0x20e20
leaq 0x10(%rsp), %rdi
callq 0x2ce0
movq 0x3da8e(%rip), %rax     # 0x40fd0
movq (%rax), %rdi
callq 0x2100
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x355b
jmp 0x36fb
leaq 0xa0(%rsp), %rdi
callq 0x22f0
leaq 0x90(%rsp), %rdi
callq 0x22f0
leaq 0x80(%rsp), %rdi
callq 0x22f0
leaq 0x70(%rsp), %rdi
callq 0x22f0
leaq 0x60(%rsp), %rdi
callq 0x22f0
cmpl $0x0, 0xa4(%rsp)
jge 0x35ab
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0xc(%rsp)
jmp 0x35bf
cmpl $0x0, 0xa4(%rsp)
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl $0x0, %eax
jne 0x35cd
jmp 0x36fb
leaq 0x50(%rsp), %rdi
callq 0x4a80
leaq 0x40(%rsp), %rdi
callq 0x4a80
leaq 0x30(%rsp), %rdi
callq 0x4a80
leaq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x70c0
cmpl $0x0, 0x34(%rsp)
jge 0x360b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x8(%rsp)
jmp 0x361c
cmpl $0x0, 0x34(%rsp)
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl $0x0, %eax
jne 0x363e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x90(%rsp), %rdx
callq 0x8130
jmp 0x35f9
leaq 0x50(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0xa0(%rsp), %rcx
callq 0x23a0
leaq 0x70(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0xa0(%rsp), %rcx
callq 0x23a0
leaq 0x40(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x70(%rsp), %rdx
leaq 0xa0(%rsp), %rcx
callq 0x2b40
leaq 0x50(%rsp), %rsi
leaq 0x33981(%rip), %rdi     # 0x37022
movb $0x0, %al
callq 0x20ba0
leaq 0x40(%rsp), %rsi
leaq 0x3396e(%rip), %rdi     # 0x37022
movb $0x0, %al
callq 0x20ba0
leaq 0xa0(%rsp), %rdi
callq 0x4460
leaq 0x90(%rsp), %rdi
callq 0x4460
leaq 0x80(%rsp), %rdi
callq 0x4460
leaq 0x70(%rsp), %rdi
callq 0x4460
leaq 0x60(%rsp), %rdi
callq 0x4460
jmp 0x353b
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/an4[P]Applied-Security-Mod/modmul.c
// Function: stage4
void stage4() {

     // fill in this function with solution
    mpz_t p, q, g, x, c1, c2, m;

    while(!feof(stdin)) {
        initialize_and_read(p);
        initialize_and_read(q);
        initialize_and_read(g);
        initialize_and_read(x);
        initialize_and_read(c1);
        initialize_and_read(c2);

        if(mpz_cmp_ui(p, 0) == 0) {
            return;
        }

        mpz_init(m);

        // -x (mod q)
        mpz_mod(x, x, q);
        mpz_neg(x, x);
        mpz_add(x, x, q);

        //mpz_powm(c1, c1, x, p);
        sliding_window_exponentiation(c1, c1, x, p);

        // mpz_mul(m, c1, c2);
        // mpz_mod(m, m, p);
        montgomery(m, c1, c2, p);

        gmp_printf( "%Zx\n", m );

        mpz_clear(p);
        mpz_clear(q);
        mpz_clear(g);
        mpz_clear(x);
        mpz_clear(c1);
        mpz_clear(c2);
        mpz_clear(m);
    }
}

// Assembly:
subq $0x88, %rsp
movq 0x3d8b2(%rip), %rax     # 0x40fd0
movq (%rax), %rdi
callq 0x2100
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3737
jmp 0x3875
leaq 0x70(%rsp), %rdi
callq 0x22f0
leaq 0x60(%rsp), %rdi
callq 0x22f0
leaq 0x50(%rsp), %rdi
callq 0x22f0
leaq 0x40(%rsp), %rdi
callq 0x22f0
leaq 0x30(%rsp), %rdi
callq 0x22f0
leaq 0x20(%rsp), %rdi
callq 0x22f0
cmpl $0x0, 0x74(%rsp)
jge 0x3785
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0xc(%rsp)
jmp 0x3796
cmpl $0x0, 0x74(%rsp)
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl $0x0, %eax
jne 0x37a4
jmp 0x3875
leaq 0x10(%rsp), %rdi
callq 0x4a80
leaq 0x40(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x4d60
leaq 0x40(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x53a0
leaq 0x40(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x40c0
leaq 0x30(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x40(%rsp), %rdx
leaq 0x70(%rsp), %rcx
callq 0x23a0
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdx
leaq 0x70(%rsp), %rcx
callq 0x2b40
leaq 0x10(%rsp), %rsi
leaq 0x337ff(%rip), %rdi     # 0x37022
movb $0x0, %al
callq 0x20ba0
leaq 0x70(%rsp), %rdi
callq 0x4460
leaq 0x60(%rsp), %rdi
callq 0x4460
leaq 0x50(%rsp), %rdi
callq 0x4460
leaq 0x40(%rsp), %rdi
callq 0x4460
leaq 0x30(%rsp), %rdi
callq 0x4460
leaq 0x20(%rsp), %rdi
callq 0x4460
leaq 0x10(%rsp), %rdi
callq 0x4460
jmp 0x3717
addq $0x88, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/an4[P]Applied-Security-Mod/modmul.c
// Function: Test_exponentiation
void Test_exponentiation() {
    mpz_t base;
    mpz_t exp;
    mpz_t N;
    mpz_t result;
    mpz_t result_test;

    initialize_and_read(base);
    initialize_and_read(exp);
    initialize_and_read(N);

    // Modular exponentiation
    mpz_init(result_test);
    mpz_powm(result_test, base, exp, N);

    // Sliding window modular exponentiation
    mpz_init(result);
    sliding_window_exponentiation(result, base, exp, N);

    assert(mpz_cmp(result, result_test) == 0);

    mpz_clear(base);
    mpz_clear(exp);
    mpz_clear(N);
    mpz_clear(result);
}

// Assembly:
subq $0x58, %rsp
leaq 0x40(%rsp), %rdi
callq 0x22f0
leaq 0x30(%rsp), %rdi
callq 0x22f0
leaq 0x20(%rsp), %rdi
callq 0x22f0
movq %rsp, %rdi
callq 0x4a80
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq 0x5460
leaq 0x10(%rsp), %rdi
callq 0x4a80
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq 0x23a0
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x4490
cmpl $0x0, %eax
jne 0x3d38
jmp 0x3d57
leaq 0x333a1(%rip), %rdi     # 0x370e0
leaq 0x332fb(%rip), %rsi     # 0x37041
movl $0x2ac, %edx            # imm = 0x2AC
leaq 0x333b0(%rip), %rcx     # 0x37102
callq 0x20c0
leaq 0x40(%rsp), %rdi
callq 0x4460
leaq 0x30(%rsp), %rdi
callq 0x4460
leaq 0x20(%rsp), %rdi
callq 0x4460
leaq 0x10(%rsp), %rdi
callq 0x4460
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/an4[P]Applied-Security-Mod/modmul.c
// Function: Test_ElGamal
void Test_ElGamal() {
    mpz_t p,q,g,x,m,h,nx,c1,c2,k,m1;

    initialize_and_read(p);
    initialize_and_read(q);
    initialize_and_read(g);
    initialize_and_read(x);
    initialize_and_read(m);

    // compute h
    mpz_init(h);
    mpz_powm(h, g, x, p);

    gmp_randstate_t state;
    gmp_randinit_default(state);

    getSeed(state);

    // encrypt

    mpz_init(c1);
    mpz_init(c2);
    mpz_init(k);
    mpz_set_ui(k, 0);
    // Random
    while(mpz_cmp_ui(k, 0) == 0){
        mpz_urandomm(k, state, q);
    }

    sliding_window_exponentiation(c1, g, k, p);
    sliding_window_exponentiation(h, h, k, p);
    montgomery(c2, m, h, p);

    // decrypt

    mpz_init(m1);
    // -x (mod q)
    mpz_init(nx);
    mpz_mod(nx, x, q);
    mpz_neg(nx, nx);
    mpz_add(nx, nx, q);

    sliding_window_exponentiation(c1, c1, nx, p);
    montgomery(m1, c1, c2, p);

    assert(mpz_cmp(m1, m) == 0);
}

// Assembly:
subq $0xe8, %rsp
leaq 0xd0(%rsp), %rdi
callq 0x22f0
leaq 0xc0(%rsp), %rdi
callq 0x22f0
leaq 0xb0(%rsp), %rdi
callq 0x22f0
leaq 0xa0(%rsp), %rdi
callq 0x22f0
leaq 0x90(%rsp), %rdi
callq 0x22f0
leaq 0x80(%rsp), %rdi
callq 0x4a80
leaq 0x80(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
leaq 0xd0(%rsp), %rcx
callq 0x5460
leaq 0x10(%rsp), %rdi
callq 0x20e20
leaq 0x10(%rsp), %rdi
callq 0x2ce0
leaq 0x60(%rsp), %rdi
callq 0x4a80
leaq 0x50(%rsp), %rdi
callq 0x4a80
leaq 0x40(%rsp), %rdi
callq 0x4a80
leaq 0x40(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x70c0
cmpl $0x0, 0x44(%rsp)
jge 0x3e5c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0xc(%rsp)
jmp 0x3e6d
cmpl $0x0, 0x44(%rsp)
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl $0x0, %eax
jne 0x3e8f
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
callq 0x8130
jmp 0x3e4a
leaq 0x60(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x40(%rsp), %rdx
leaq 0xd0(%rsp), %rcx
callq 0x23a0
leaq 0x80(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x40(%rsp), %rdx
leaq 0xd0(%rsp), %rcx
callq 0x23a0
leaq 0x50(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x80(%rsp), %rdx
leaq 0xd0(%rsp), %rcx
callq 0x2b40
leaq 0x30(%rsp), %rdi
callq 0x4a80
leaq 0x70(%rsp), %rdi
callq 0x4a80
leaq 0x70(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
callq 0x4d60
leaq 0x70(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x53a0
leaq 0x70(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
callq 0x40c0
leaq 0x60(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x70(%rsp), %rdx
leaq 0xd0(%rsp), %rcx
callq 0x23a0
leaq 0x30(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x50(%rsp), %rdx
leaq 0xd0(%rsp), %rcx
callq 0x2b40
leaq 0x30(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x4490
cmpl $0x0, %eax
jne 0x3f97
jmp 0x3fb6
leaq 0x3317f(%rip), %rdi     # 0x3711d
leaq 0x3309c(%rip), %rsi     # 0x37041
movl $0x2e1, %edx            # imm = 0x2E1
leaq 0x33180(%rip), %rcx     # 0x37131
callq 0x20c0
addq $0xe8, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/an4[P]Applied-Security-Mod/modmul.c
// Function: main
int main( int argc, char* argv[] ) {
    if( argc != 2 ) {
    abort();
    }

    if     ( !strcmp( argv[ 1 ], "stage1" ) ) {
    stage1();
    }
    else if( !strcmp( argv[ 1 ], "stage2" ) ) {
    stage2();
    }
    else if( !strcmp( argv[ 1 ], "stage3" ) ) {
    stage3();
    }
    else if( !strcmp( argv[ 1 ], "stage4" ) ) {
    stage4();
    }
	else if( !strcmp( argv[ 1 ], "test" ) ) {
    Test();
    }
    else {
    abort();
    }

    return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x2, 0x10(%rsp)
je 0x4001
callq 0x2060
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x33134(%rip), %rsi     # 0x37145
callq 0x20f0
cmpl $0x0, %eax
jne 0x4025
callq 0x3280
jmp 0x40b6
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x33117(%rip), %rsi     # 0x3714c
callq 0x20f0
cmpl $0x0, %eax
jne 0x4046
callq 0x3360
jmp 0x40b4
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x330fd(%rip), %rsi     # 0x37153
callq 0x20f0
cmpl $0x0, %eax
jne 0x4067
callq 0x3520
jmp 0x40b2
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x330e3(%rip), %rsi     # 0x3715a
callq 0x20f0
cmpl $0x0, %eax
jne 0x4088
callq 0x3710
jmp 0x40b0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x330c9(%rip), %rsi     # 0x37161
callq 0x20f0
cmpl $0x0, %eax
jne 0x40a9
callq 0x3fc0
jmp 0x40ae
callq 0x2060
jmp 0x40b0
jmp 0x40b2
jmp 0x40b4
jmp 0x40b6
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/3-ProcessUser/system_implement_1.c
// Function: system_ver_3150
int system_ver_3150(const char *cmd_str) {
	if(cmd_str == NULL)
		return -1;
	if(fork() == 0) {
		//sleep(2);
		execl(cmd_str, cmd_str, NULL);
		fprintf(stderr, "%s: command not found\n", cmd_str);
		exit(-1);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x11ac
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11f6
callq 0x1080
cmpl $0x0, %eax
jne 0x11ef
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x1070
movq 0x2e28(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0xe26(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1040
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1060
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/3-ProcessUser/system_implement_1.c
// Function: main
int main(void) {
	printf("\033[1;30m\033[1;42mbefore..\n\033[0m\n");
	printf("\033[1;37m\033[1;41m");
	fflush(stdout);
	system_ver_3150("/bin/ls");
	printf("\033[1;30m\033[1;42m\nafter..\n\033[0m");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xe05(%rip), %rdi       # 0x201b
movb $0x0, %al
callq 0x1030
leaq 0xe14(%rip), %rdi       # 0x2038
movb $0x0, %al
callq 0x1030
movq 0x2da6(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x1050
leaq 0xe06(%rip), %rdi       # 0x2047
callq 0x1190
leaq 0xe02(%rip), %rdi       # 0x204f
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/lz78/wrapper.c
// Function: wrapper_return
uint8_t wrapper_return(uint8_t code) {
    wrapper_cur_err = code;
    switch (code) {
        case LZ78_SUCCESS:
            return WRAPPER_SUCCESS;
        case LZ78_ERROR_READ:
            return WRAPPER_ERROR_READ;
        case LZ78_ERROR_WRITE:
            return WRAPPER_ERROR_WRITE;
        case LZ78_ERROR_EAGAIN:
            return WRAPPER_ERROR_EAGAIN;
        case LZ78_ERROR_COMPRESS:
            return WRAPPER_ERROR_COMPRESS;
        case LZ78_ERROR_DECOMPRESS:
            return WRAPPER_ERROR_DECOMPRESS;
        case LZ78_ERROR_DICTIONARY:
        case LZ78_ERROR_INITIALIZATION:
        case LZ78_ERROR_MODE:
            return WRAPPER_ERROR_GENERIC;
    }
    return code;
}

// Assembly:
movb %dil, %al
movb %al, -0x2(%rsp)
movb -0x2(%rsp), %al
movb %al, 0x4c27(%rip)       # 0x60c8
movzbl -0x2(%rsp), %eax
movq %rax, -0x10(%rsp)
subq $0x8, %rax
ja 0x14f7
movq -0x10(%rsp), %rax
leaq 0x2cfb(%rip), %rcx      # 0x41b8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x14, -0x1(%rsp)
jmp 0x14ff
movb $0x18, -0x1(%rsp)
jmp 0x14ff
movb $0x19, -0x1(%rsp)
jmp 0x14ff
movb $0x1a, -0x1(%rsp)
jmp 0x14ff
movb $0x1b, -0x1(%rsp)
jmp 0x14ff
movb $0x1c, -0x1(%rsp)
jmp 0x14ff
movb $0x1d, -0x1(%rsp)
jmp 0x14ff
movb -0x2(%rsp), %al
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/lz78/wrapper.c
// Function: get_algorithm
uint8_t get_algorithm(char* type) {
    uint8_t i = 0;
    while (algo_list[i].name != NULL) {
        if (strcmp(type, algo_list[i].name) == 0)
            return algo_list[i].type;
        ++i;
    }
    return UNKNOWN_ALGORITHM;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movb $0x0, 0x7(%rsp)
movzbl 0x7(%rsp), %eax
movl %eax, %ecx
leaq 0x4894(%rip), %rax      # 0x5dc0
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x158a
movq 0x8(%rsp), %rdi
movzbl 0x7(%rsp), %eax
movl %eax, %ecx
leaq 0x4874(%rip), %rax      # 0x5dc0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x157e
movzbl 0x7(%rsp), %eax
movl %eax, %ecx
leaq 0x4852(%rip), %rax      # 0x5dc0
shlq $0x4, %rcx
addq %rcx, %rax
movb 0x8(%rax), %al
movb %al, 0x17(%rsp)
jmp 0x158f
movb 0x7(%rsp), %al
addb $0x1, %al
movb %al, 0x7(%rsp)
jmp 0x151e
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/lz78/wrapper.c
// Function: byte_size
int byte_size(char* size) {
    int n;

    if (size == NULL)
        return 0;

    n = atoi(size);

    switch (size[strlen(size) - 1]) {
        case 'K':
            n <<= 10;
            break;
    
        case 'M':
            n <<= 20;
            break;
    }

    return (n < 0) ? 0 : n;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x15bb
movl $0x0, 0x24(%rsp)
jmp 0x162f
movq 0x18(%rsp), %rdi
callq 0x1140
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1060
movq 0x8(%rsp), %rcx
movsbl -0x1(%rax,%rcx), %eax
movl %eax, 0x10(%rsp)
subl $0x4b, %eax
je 0x15f8
jmp 0x15ed
movl 0x10(%rsp), %eax
subl $0x4d, %eax
je 0x1605
jmp 0x1610
movl 0x14(%rsp), %eax
shll $0xa, %eax
movl %eax, 0x14(%rsp)
jmp 0x1610
movl 0x14(%rsp), %eax
shll $0x14, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x161f
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x1627
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/lz78/wrapper.c
// Function: wrapper_new
wrapper* wrapper_new(uint8_t w_mode, uint8_t w_type, char* argv) {
    wrapper* w = malloc(sizeof(wrapper));
    if (w == NULL)
        return NULL;

    w->type = w_type;
    w->mode = w_mode;

    switch (w->type) {
        case LZ78_ALGORITHM:
            w->data = lz78_new(w_mode, byte_size(argv));
            break;

        default:
            free(w);
            return NULL;
    }

    if (w->data)
        return w;
    else {
        free(w);
        return NULL;
    }
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, 0x1f(%rsp)
movb %al, 0x1e(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x10, %edi
callq 0x10f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x180c
movq $0x0, 0x20(%rsp)
jmp 0x189e
movb 0x1e(%rsp), %cl
movq 0x8(%rsp), %rax
movb %cl, (%rax)
movb 0x1f(%rsp), %cl
movq 0x8(%rsp), %rax
movb %cl, 0x1(%rax)
movq 0x8(%rsp), %rax
movb (%rax), %al
subb $0x1, %al
jne 0x185e
jmp 0x1830
movb 0x1f(%rsp), %al
movb %al, 0x7(%rsp)
movq 0x10(%rsp), %rdi
callq 0x15a0
movl %eax, %esi
movb 0x7(%rsp), %al
movzbl %al, %edi
callq 0x2730
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x1873
movq 0x8(%rsp), %rdi
callq 0x1030
movq $0x0, 0x20(%rsp)
jmp 0x189e
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x188b
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x189e
movq 0x8(%rsp), %rdi
callq 0x1030
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/lz78/wrapper.c
// Function: wrapper_destroy
void wrapper_destroy(wrapper* w) {
    if (w == NULL)
        return;

    switch (w->type) {
        case LZ78_ALGORITHM:
            lz78_destroy(w->data);
            break;

        default:
            return;
    }
    free(w);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x18be
jmp 0x18e4
movq (%rsp), %rax
movb (%rax), %al
subb $0x1, %al
jne 0x18d9
jmp 0x18ca
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2d50
jmp 0x18db
jmp 0x18e4
movq (%rsp), %rdi
callq 0x1030
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/lz78/wrapper.c
// Function: wrapper_compress
uint8_t wrapper_compress(wrapper* w, char* input, char* output) {
    uint8_t ret;
    int fd_in;
    int fd_out;

    switch (w->type) {
        case LZ78_ALGORITHM:
            if (input == NULL) {
                fd_in = STDIN_FILENO;
            } else {
                fd_in = open(input, ACCESS_READ);
                if (fd_in == -1)
                    return wrapper_return(WRAPPER_ERROR_FILE_IN);
            }

            if (output == NULL) {
                fd_out = STDOUT_FILENO;
            } else {
                fd_out = open(output, ACCESS_WRITE, 0644);
                if (fd_out == -1) {
                    close(fd_in);
                    return wrapper_return(WRAPPER_ERROR_FILE_OUT);
                }
            }

            ret = lz78_compress(w->data, fd_in, fd_out);

            close(fd_in);
            close(fd_out);
            return wrapper_return(ret);

        default:
            return wrapper_return(WRAPPER_ERROR_ALGORITHM);
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movb (%rax), %al
subb $0x1, %al
jne 0x19e1
jmp 0x1914
cmpq $0x0, 0x20(%rsp)
jne 0x1926
movl $0x0, 0x10(%rsp)
jmp 0x1957
movq 0x20(%rsp), %rdi
movl $0x800, %esi            # imm = 0x800
movb $0x0, %al
callq 0x1120
movl %eax, 0x10(%rsp)
cmpl $-0x1, 0x10(%rsp)
jne 0x1955
movl $0x16, %edi
callq 0x1490
movb %al, 0x37(%rsp)
jmp 0x19ef
jmp 0x1957
cmpq $0x0, 0x18(%rsp)
jne 0x1969
movl $0x1, 0xc(%rsp)
jmp 0x19a5
movq 0x18(%rsp), %rdi
movl $0xa41, %esi            # imm = 0xA41
movl $0x1a4, %edx            # imm = 0x1A4
movb $0x0, %al
callq 0x1120
movl %eax, 0xc(%rsp)
cmpl $-0x1, 0xc(%rsp)
jne 0x19a3
movl 0x10(%rsp), %edi
callq 0x1090
movl $0x17, %edi
callq 0x1490
movb %al, 0x37(%rsp)
jmp 0x19ef
jmp 0x19a5
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
callq 0x2950
movb %al, 0x17(%rsp)
movl 0x10(%rsp), %edi
callq 0x1090
movl 0xc(%rsp), %edi
callq 0x1090
movzbl 0x17(%rsp), %edi
callq 0x1490
movb %al, 0x37(%rsp)
jmp 0x19ef
movl $0x15, %edi
callq 0x1490
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/lz78/wrapper.c
// Function: wrapper_exec
uint8_t wrapper_exec(wrapper* w, char* input, char* output) {
    uint8_t ret;

    if (w->mode == WRAPPER_MODE_COMPRESS) {
        for (;;) {
            ret = wrapper_compress(w, input, output);
            if (ret != WRAPPER_ERROR_EAGAIN)
                return ret;
        }
    } else {
        for (;;) {
            ret = wrapper_decompress(w, input, output);
            if (ret != WRAPPER_ERROR_EAGAIN)
                return ret;
        }
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x1b61
jmp 0x1b33
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x18f0
movb %al, 0x7(%rsp)
movzbl 0x7(%rsp), %eax
cmpl $0x1a, %eax
je 0x1b5f
movb 0x7(%rsp), %al
movb %al, 0x27(%rsp)
jmp 0x1b91
jmp 0x1b33
jmp 0x1b63
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x1a00
movb %al, 0x7(%rsp)
movzbl 0x7(%rsp), %eax
cmpl $0x1a, %eax
je 0x1b8f
movb 0x7(%rsp), %al
movb %al, 0x27(%rsp)
jmp 0x1b91
jmp 0x1b63
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/lz78/lz78.c
// Function: bitlen
uint8_t bitlen(uint32_t i) {
    uint8_t n = 0;
    while (i) {
        ++n;
        i >>= 1;
    }
    return n;
}

// Assembly:
movl %edi, -0x4(%rsp)
movb $0x0, -0x5(%rsp)
cmpl $0x0, -0x4(%rsp)
je 0x1bc6
movb -0x5(%rsp), %al
addb $0x1, %al
movb %al, -0x5(%rsp)
movl -0x4(%rsp), %eax
shrl %eax
movl %eax, -0x4(%rsp)
jmp 0x1ba9
movb -0x5(%rsp), %al
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/lz78/lz78.c
// Function: ht_dictionary_new
ht_dictionary* ht_dictionary_new(uint32_t d_size) {
    ht_dictionary* dict = malloc(sizeof(ht_dictionary));
    if (dict == NULL)
        return NULL;

    d_size = DICT_LIMIT(d_size);
    dict->root = calloc(1, sizeof(ht_entry) * d_size);
    if (dict->root == NULL) {
        free(dict);
        return NULL;
    } else {
        dict->d_size = d_size;
        dict->d_thr = DICT_SIZE_THRESHOLD(d_size);
        dict->d_next = DICT_SIZE_MIN;
        dict->cur_node = -1;
        return dict;
    }
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movl $0x20, %edi
callq 0x10f0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1bfd
movq $0x0, 0x20(%rsp)
jmp 0x1cc6
cmpl $0x105, 0x1c(%rsp)      # imm = 0x105
jae 0x1c12
movl $0x105, %eax            # imm = 0x105
movl %eax, 0xc(%rsp)
jmp 0x1c37
cmpl $0x100000, 0x1c(%rsp)   # imm = 0x100000
jbe 0x1c27
movl $0x100000, %eax         # imm = 0x100000
movl %eax, 0x8(%rsp)
jmp 0x1c2f
movl 0x1c(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, %esi
shlq $0x4, %rsi
movl $0x1, %edi
callq 0x10b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1c7e
movq 0x10(%rsp), %rdi
callq 0x1030
movq $0x0, 0x20(%rsp)
jmp 0x1cc6
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
movl 0x1c(%rsp), %eax
shll $0x3, %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x10(%rsp), %rax
movl $0x104, 0x18(%rax)      # imm = 0x104
movq 0x10(%rsp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/lz78/lz78.c
// Function: dictionary_new
dictionary* dictionary_new(uint32_t d_size) {
    uint16_t i;
    dictionary* dict = malloc(sizeof(dictionary) + d_size);
    if (dict == NULL)
        return NULL;

    d_size = DICT_LIMIT(d_size);
    dict->root = malloc(sizeof(entry) * d_size);
    if (dict->root == NULL) {
        free(dict);
        return NULL;
    }

    dict->d_size = d_size;
    dict->d_thr = DICT_SIZE_THRESHOLD(d_size);
    dict->d_min = DICT_SIZE_MIN;
    dict->d_next = DICT_SIZE_MIN;
    for (i = 0; i < DICT_SIZE_MIN; ++i) {
        dict->root[i].parent = 0;
        dict->root[i].label = i;
    }
    return dict;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, %edi
addq $0x20, %rdi
callq 0x10f0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1f72
movq $0x0, 0x20(%rsp)
jmp 0x2087
cmpl $0x105, 0x1c(%rsp)      # imm = 0x105
jae 0x1f87
movl $0x105, %eax            # imm = 0x105
movl %eax, 0xc(%rsp)
jmp 0x1fac
cmpl $0x100000, 0x1c(%rsp)   # imm = 0x100000
jbe 0x1f9c
movl $0x100000, %eax         # imm = 0x100000
movl %eax, 0x8(%rsp)
jmp 0x1fa4
movl 0x1c(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x10f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1ff1
movq 0x10(%rsp), %rdi
callq 0x1030
movq $0x0, 0x20(%rsp)
jmp 0x2087
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0x1c(%rsp), %eax
shll $0x3, %eax
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x10(%rsp), %rax
movl $0x104, 0x10(%rax)      # imm = 0x104
movq 0x10(%rsp), %rax
movl $0x104, 0x14(%rax)      # imm = 0x104
movw $0x0, 0x1a(%rsp)
movzwl 0x1a(%rsp), %eax
cmpl $0x104, %eax            # imm = 0x104
jge 0x207d
movq 0x10(%rsp), %rax
movq (%rax), %rax
movzwl 0x1a(%rsp), %ecx
movl $0x0, (%rax,%rcx,8)
movw 0x1a(%rsp), %dx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movzwl 0x1a(%rsp), %ecx
movw %dx, 0x4(%rax,%rcx,8)
movw 0x1a(%rsp), %ax
addw $0x1, %ax
movw %ax, 0x1a(%rsp)
jmp 0x2036
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/lz78/lz78.c
// Function: dictionary_update
void dictionary_update(dictionary* d, uint32_t code) {
    uint32_t d_size = d->d_size - 1;
    uint32_t d_next = d->d_next;
    uint32_t d_min = d->d_min;
    uint32_t i = d_size;
    uint32_t p = code;

    /* Recover original sequence */
    while (1) {
        d->bytebuf[i--] = d->root[p].label;
        if (p < DICT_SIZE_MIN || i == 0)
            break;
        p = d->root[p].parent;
    }

    /* Fill last char with the first char of the sequence */
    if (code >= d_min && code == d_next - 1)
        d->bytebuf[d_size] = d->bytebuf[i + 1];

    /* Update last incomplete entry of the dictionary */
    if (d_next > d_min)
        d->root[d_next - 1].label = d->bytebuf[i + 1];

    /* Update */
    d->n_bytes = d_size - i;
    d->offset = d_size + 1 - d->n_bytes;
    d->root[d_next].parent = code;
    ++(d->d_next);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x14(%rsp)
movq -0x8(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x18(%rsp)
movl -0x10(%rsp), %eax
movl %eax, -0x1c(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movl -0x20(%rsp), %ecx
movw 0x4(%rax,%rcx,8), %ax
movb %al, %dl
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
movl %ecx, %esi
addl $-0x1, %esi
movl %esi, -0x1c(%rsp)
movl %ecx, %ecx
movb %dl, 0x20(%rax,%rcx)
cmpl $0x104, -0x20(%rsp)     # imm = 0x104
jb 0x211c
cmpl $0x0, -0x1c(%rsp)
jne 0x211e
jmp 0x2133
movq -0x8(%rsp), %rax
movq (%rax), %rax
movl -0x20(%rsp), %ecx
movl (%rax,%rcx,8), %eax
movl %eax, -0x20(%rsp)
jmp 0x20e0
movl -0xc(%rsp), %eax
cmpl -0x18(%rsp), %eax
jb 0x216b
movl -0xc(%rsp), %eax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x216b
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb 0x20(%rax,%rcx), %dl
movq -0x8(%rsp), %rax
movl -0x10(%rsp), %ecx
movb %dl, 0x20(%rax,%rcx)
movl -0x14(%rsp), %eax
cmpl -0x18(%rsp), %eax
jbe 0x21a1
movq -0x8(%rsp), %rax
movl -0x1c(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movsbl 0x20(%rax,%rcx), %eax
movw %ax, %dx
movq -0x8(%rsp), %rax
movq (%rax), %rax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movw %dx, 0x4(%rax,%rcx,8)
movl -0x10(%rsp), %ecx
subl -0x1c(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x18(%rax)
movl -0x10(%rsp), %ecx
addl $0x1, %ecx
movq -0x8(%rsp), %rax
subl 0x18(%rax), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x1c(%rax)
movl -0xc(%rsp), %edx
movq -0x8(%rsp), %rax
movq (%rax), %rax
movl -0x14(%rsp), %ecx
movl %edx, (%rax,%rcx,8)
movq -0x8(%rsp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/lz78/lz78.c
// Function: lz78_compress
uint8_t lz78_compress(lz78_instance* lz78, int fd_in, int fd_out) {
    FILE* in;
    bit_file* out;
    lz78_c* o;
    int bits;
    int c_in;

    if (lz78 == NULL)
        return LZ78_ERROR_INITIALIZATION;

    if (lz78->mode != LZ78_MODE_COMPRESS)
        return LZ78_ERROR_MODE;

    in = fdopen(fd_in, "r");
    if (in == NULL)
        return LZ78_ERROR_READ;

    out = bit_open(fd_out, ACCESS_WRITE, B_SIZE_DEFAULT);
    if (out == NULL)
        return LZ78_ERROR_WRITE;

    o = (lz78_c*)&lz78->state;

    for (;;) {

        if (o->n_bits > 0) {
            bits = bit_write(out, (char*) &o->bitbuf, o->n_bits, 0);
            if (bits == -1)
                return LZ78_ERROR_WRITE;

            o->bitbuf >>= bits;
            o->n_bits -= bits;

            if (o->n_bits > 0)
                return LZ78_ERROR_EAGAIN;
        }

        c_in = fgetc(in);
        if (c_in == EOF) {
            if (errno == EAGAIN) {
                errno = 0;
                return LZ78_ERROR_EAGAIN;
            } else if (errno != 0) {
                return LZ78_ERROR_READ;
            }
        }

        compress_byte(o, c_in);
        if (o->completed == 1) {
            bit_close(out);
            return LZ78_SUCCESS;
        }
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x2973
movb $0x7, 0x37(%rsp)
jmp 0x2ad2
movq 0x28(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0x298a
movb $0x8, 0x37(%rsp)
jmp 0x2ad2
movl 0x24(%rsp), %edi
leaq 0x1a49(%rip), %rsi      # 0x43de
callq 0x1110
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x29b1
movb $0x2, 0x37(%rsp)
jmp 0x2ad2
movl 0x20(%rsp), %edi
movl $0xa41, %esi            # imm = 0xA41
movl $0x100000, %edx         # imm = 0x100000
callq 0x2e20
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x29db
movb $0x3, 0x37(%rsp)
jmp 0x2ad2
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
jbe 0x2a5e
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
movq 0x8(%rsp), %rax
movl 0x1c(%rax), %edx
xorl %ecx, %ecx
callq 0x32b0
movl %eax, 0x4(%rsp)
cmpl $-0x1, 0x4(%rsp)
jne 0x2a26
movb $0x3, 0x37(%rsp)
jmp 0x2ad2
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rax
movl 0x18(%rax), %edx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x18(%rax)
movl 0x4(%rsp), %edx
movq 0x8(%rsp), %rax
movl 0x1c(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x1c(%rax)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
jbe 0x2a5c
movb $0x4, 0x37(%rsp)
jmp 0x2ad2
jmp 0x2a5e
movq 0x18(%rsp), %rdi
callq 0x1080
movl %eax, (%rsp)
cmpl $-0x1, (%rsp)
jne 0x2aa2
callq 0x1040
cmpl $0xb, (%rax)
jne 0x2a8d
callq 0x1040
movl $0x0, (%rax)
movb $0x4, 0x37(%rsp)
jmp 0x2ad2
callq 0x1040
cmpl $0x0, (%rax)
je 0x2a9e
movb $0x2, 0x37(%rsp)
jmp 0x2ad2
jmp 0x2aa0
jmp 0x2aa2
movq 0x8(%rsp), %rdi
movl (%rsp), %esi
callq 0x2240
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x1, %eax
jne 0x2acd
movq 0x10(%rsp), %rdi
callq 0x3700
movb $0x0, 0x37(%rsp)
jmp 0x2ad2
jmp 0x29e9
movb 0x37(%rsp), %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/lz78/lz78.c
// Function: lz78_destroy
void lz78_destroy(lz78_instance *lz78) {
    lz78_c *c;
    lz78_d *d;
    if (lz78 != NULL) {
        switch (lz78->mode) {
            case LZ78_MODE_COMPRESS:
                c = (lz78_c*)&lz78->state;
                if (c != NULL) {
                    ht_dictionary_destroy(c->main);
                    ht_dictionary_destroy(c->secondary);
                }
                break;

            case LZ78_MODE_DECOMPRESS:
                d = (lz78_d*)&lz78->state;
                if (d != NULL) {
                    dictionary_destroy(d->main);
                    ht_dictionary_destroy(d->secondary);
                }
                break;
        }

        free(lz78);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x2df4
movq 0x20(%rsp), %rax
movzbl (%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x2d82
jmp 0x2d77
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x2db6
jmp 0x2dea
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x2db4
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1f20
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f20
jmp 0x2dea
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2de8
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2210
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f20
jmp 0x2dea
movq 0x20(%rsp), %rdi
callq 0x1030
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/lz78/bitio.c
// Function: bit_open
bit_file* bit_open(int fd, int mode, UINTMAX_T buff_size) {

    bit_file* bfp;
    int ret;

    if (mode != ACCESS_READ && mode != ACCESS_WRITE)
        return NULL;
    
    if (mode == ACCESS_READ)
        ret = read(fd, NULL, 0);
    else /* mode == ACCESS_WRITE */
        ret = write(fd, NULL, 0);

    if(ret != 0)
        return NULL;

    if (buff_size % 8 != 0)
        return NULL;

    buff_size = (buff_size > max_index()) ? max_index() : buff_size;

    /* Buffer allocation */
    bfp = (bit_file*) calloc(1, sizeof(bit_file) + buff_size / 8);
    if (bfp == NULL) {
        close(fd);
    } else {
        bfp->fd = fd;
        bfp->mode = mode;
        bfp->buff_size = buff_size;
        /* bfp->w_start and bfp->w_len are initialized by calloc */
    }

    return bfp;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x2c(%rsp)
movl %esi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
cmpl $0x800, 0x28(%rsp)      # imm = 0x800
je 0x2e52
cmpl $0xa41, 0x28(%rsp)      # imm = 0xA41
je 0x2e52
movq $0x0, 0x30(%rsp)
jmp 0x2f45
cmpl $0x800, 0x28(%rsp)      # imm = 0x800
jne 0x2e72
movl 0x2c(%rsp), %edi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x10a0
movl %eax, 0x14(%rsp)
jmp 0x2e86
movl 0x2c(%rsp), %edi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x1050
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x2e9b
movq $0x0, 0x30(%rsp)
jmp 0x2f45
movl 0x24(%rsp), %eax
andl $0x7, %eax
cmpl $0x0, %eax
je 0x2eb5
movq $0x0, 0x30(%rsp)
jmp 0x2f45
movl 0x24(%rsp), %eax
movl %eax, 0x10(%rsp)
callq 0x2e00
movl %eax, %ecx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jbe 0x2ed7
callq 0x2e00
movl %eax, 0xc(%rsp)
jmp 0x2edf
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
shrl $0x3, %eax
movl %eax, %eax
movl %eax, %esi
addq $0x14, %rsi
movl $0x1, %edi
callq 0x10b0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x2f18
movl 0x2c(%rsp), %edi
callq 0x1090
jmp 0x2f3b
movl 0x2c(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movl 0x28(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x24(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/lz78/bitio.c
// Function: bit_flush
int bit_flush(bit_file* bfp) {
    UINTMAX_T count;
    UINTMAX_T written;
    UINTMAX_T n;
    uint8_t* base;

    if (bfp == NULL)
        return -1;

    count = bfp->w_len / 8;
    written = 0;
    base = (uint8_t*) bfp->buff + bfp->w_start / 8;

    while (count > 0) {
        n = write(bfp->fd, base, count);
        if (n == -1) {
            if (errno == EAGAIN) {
                errno = 0;
                break;
            } else {
                return -1;
            }
        }
        base += n;
        written += n;
        count -= n;
    }

    bfp->w_start = (bfp->w_start + written * 8) % bfp->buff_size;
    bfp->w_len -= written * 8;
    return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x360e
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x36f7
movq 0x18(%rsp), %rax
movl 0x10(%rax), %eax
shrl $0x3, %eax
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rax
addq $0x14, %rax
movq 0x18(%rsp), %rcx
movl 0xc(%rcx), %ecx
shrl $0x3, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, (%rsp)
cmpl $0x0, 0x14(%rsp)
jbe 0x36b8
movq 0x18(%rsp), %rax
movl (%rax), %edi
movq (%rsp), %rsi
movl 0x14(%rsp), %eax
movl %eax, %edx
callq 0x1050
movl %eax, 0xc(%rsp)
cmpl $-0x1, 0xc(%rsp)
jne 0x368b
callq 0x1040
cmpl $0xb, (%rax)
jne 0x3681
callq 0x1040
movl $0x0, (%rax)
jmp 0x36b8
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x36f7
movl 0xc(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, (%rsp)
movl 0xc(%rsp), %eax
addl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %ecx
movl 0x14(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x14(%rsp)
jmp 0x3642
movq 0x18(%rsp), %rax
movl 0xc(%rax), %eax
movl 0x10(%rsp), %ecx
shll $0x3, %ecx
addl %ecx, %eax
movq 0x18(%rsp), %rcx
xorl %edx, %edx
divl 0x8(%rcx)
movq 0x18(%rsp), %rax
movl %edx, 0xc(%rax)
movl 0x10(%rsp), %edx
shll $0x3, %edx
movq 0x18(%rsp), %rax
movl 0x10(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x10(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/ijleesw[P]data-compression/src/lz78/bitio.c
// Function: bit_close
int bit_close(bit_file* bfp) {
    int fd;

    if (bfp == NULL)
        return -1;

    fd = bfp->fd;

    if (bfp->w_len % 8)
        bfp->w_len += 8 - (bfp->w_len % 8);

    bit_flush(bfp);
    free(bfp);
    close(fd);
    return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x371b
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x3778
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
andl $0x7, %eax
cmpl $0x0, %eax
je 0x3753
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
andl $0x7, %eax
movl $0x8, %ecx
subl %eax, %ecx
movq 0x8(%rsp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movq 0x8(%rsp), %rdi
callq 0x35f0
movq 0x8(%rsp), %rdi
callq 0x1030
movl 0x4(%rsp), %edi
callq 0x1090
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq