LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/983[P]bigint/bigint.c
// Function: bigint_mul
bigint* bigint_mul(bigint *dst, const bigint *a, const bigint *b){
    int na = a->size;
    int nb = b->size;
    int n = na + nb;
    bigint_word *tmp;

    bigint_reserve(dst, n);

    /* bigint_raw_mul_karatsuba already has this fastpath */
    /* but this way we avoid allocating tmp */
    if (
        dst != a &&
        dst != b &&
        na < BIGINT_KARATSUBA_WORD_THRESHOLD &&
        nb < BIGINT_KARATSUBA_WORD_THRESHOLD
    ){
        bigint_raw_zero(dst->words, 0, na + nb);
        dst->size = bigint_raw_mul_add(dst->words, a->words, na, b->words, nb);
    }else{
        int magical_upper_bound = BIGINT_MAX(na, nb) * 11 + 180 + n;
        tmp = (bigint_word*)malloc(magical_upper_bound * sizeof(*tmp));

        dst->size = bigint_raw_mul_karatsuba(tmp, a->words, na, b->words, nb, tmp + n);
        bigint_raw_cpy(dst->words, tmp, dst->size);
        free(tmp);
    }

    return bigint_set_neg(dst, a->neg ^ b->neg);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
addl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x20e0
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
je 0x3737
movq 0x30(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x3737
cmpl $0x14, 0x1c(%rsp)
jge 0x3737
cmpl $0x14, 0x18(%rsp)
jge 0x3737
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movl 0x1c(%rsp), %edx
addl 0x18(%rsp), %edx
xorl %esi, %esi
callq 0x24a0
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rsi
movl 0x1c(%rsp), %edx
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movl 0x18(%rsp), %r8d
callq 0x2a20
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0xc(%rax)
jmp 0x37d9
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
jle 0x374a
movl 0x1c(%rsp), %eax
movl %eax, (%rsp)
jmp 0x3751
movl 0x18(%rsp), %eax
movl %eax, (%rsp)
movl (%rsp), %eax
imull $0xb, %eax, %eax
addl $0xb4, %eax
addl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
movslq 0x4(%rsp), %rdi
shlq $0x2, %rdi
callq 0x10c0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rsi
movl 0x1c(%rsp), %edx
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movl 0x18(%rsp), %r8d
movq 0x8(%rsp), %r9
movslq 0x14(%rsp), %rax
shlq $0x2, %rax
addq %rax, %r9
callq 0x2fe0
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
movq 0x30(%rsp), %rax
movl 0xc(%rax), %edx
callq 0x2540
movq 0x8(%rsp), %rdi
callq 0x1030
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0x8(%rax), %esi
movq 0x20(%rsp), %rax
xorl 0x8(%rax), %esi
callq 0x24f0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/983[P]bigint/bigint.c
// Function: bigint_from_str_base
bigint* bigint_from_str_base(bigint *dst, const char *src, int src_base){
    int n_digits_src, n_digits_dst;
    double dst_base = pow(2.0, BIGINT_WORD_BITS);

    n_digits_src = bigint_count_digits(src);
    n_digits_dst = bigint_digits_bound(n_digits_src, src_base, dst_base);

    bigint_reserve(dst, n_digits_dst);
    dst->size = n_digits_dst;
    bigint_raw_zero(dst->words, 0, n_digits_dst);

    dst->size = bigint_raw_from_str_base(dst->words, src, src_base);
    return bigint_set_neg(dst, *src == '-');
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movsd 0x2a1e(%rip), %xmm0     # 0x62f8
movsd 0x2a1e(%rip), %xmm1     # 0x6300
callq 0x1050
movsd %xmm0, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x2c80
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %edi
cvtsi2sdl 0x14(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x3800
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x20e0
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movl 0xc(%rsp), %edx
xorl %esi, %esi
callq 0x24a0
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
callq 0x2be0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
sete %al
andb $0x1, %al
movzbl %al, %esi
callq 0x24f0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/983[P]bigint/bigint.c
// Function: bigint_from_int
bigint* bigint_from_int(bigint *dst, int src){
    unsigned int x = BIGINT_INT_ABS(src);
    int n = BIGINT_MAX(1, sizeof(x)/sizeof(bigint_word));
    bigint_reserve(dst, n);
    bigint_raw_zero(dst->words, 0, n);
    memcpy(dst->words, &x, sizeof(x));
    dst->size = bigint_raw_truncate(dst->words, n);
    return bigint_set_neg(dst, src < 0);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x39df
xorl %eax, %eax
subl 0xc(%rsp), %eax
movl %eax, (%rsp)
jmp 0x39e6
movl 0xc(%rsp), %eax
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, 0x8(%rsp)
movl $0x1, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x20e0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl 0x4(%rsp), %edx
xorl %esi, %esi
callq 0x24a0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x8(%rsp), %ecx
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl 0x4(%rsp), %esi
callq 0x2640
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x10(%rsp), %rdi
cmpl $0x0, 0xc(%rsp)
setl %al
andb $0x1, %al
movzbl %al, %esi
callq 0x24f0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/983[P]bigint/bigint.c
// Function: bigint_from_word
bigint* bigint_from_word(bigint *dst, bigint_word a){
    bigint_reserve(dst, 1);
    dst->words[0] = a;
    dst->size = bigint_raw_truncate(dst->words, 1);
    return bigint_set_neg(dst, 0);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x20e0
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x2640
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x24f0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/983[P]bigint/bigint.c
// Function: bigint_add_signed
bigint* bigint_add_signed(
    bigint *dst,
    const bigint *a, int a_neg,
    const bigint *b, int b_neg
){
    int na = a->size;
    int nb = b->size;
    int n = BIGINT_MAX(na, nb) + 1;

    bigint_reserve(dst, n);

    dst->size = bigint_raw_add_signed(
        dst->words, &dst->neg,
        a->words, na, a_neg,
        b->words, nb, b_neg
    );

    return dst;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movq 0x38(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x1c(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jle 0x3d28
movl 0x20(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x3d30
movl 0x1c(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x20e0
movq 0x40(%rsp), %rax
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
addq $0x8, %rsi
movq 0x38(%rsp), %rax
movq (%rax), %rdx
movl 0x20(%rsp), %ecx
movl 0x34(%rsp), %r8d
movq 0x28(%rsp), %rax
movq (%rax), %r9
movl 0x1c(%rsp), %r10d
movl 0x24(%rsp), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x3ac0
movl %eax, %ecx
movq 0x40(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/983[P]bigint/bigint.c
// Function: bigint_add_word_signed
bigint* bigint_add_word_signed(
    bigint *dst,
    const bigint *src_a,
    bigint_word b, int b_neg
){
    int na = src_a->size;

    bigint_reserve(dst, na + 1);

    dst->size = bigint_raw_add_signed(
        dst->words, &dst->neg,
        src_a->words, na, src_a->neg,
        &b, 1, b_neg
    );

    return dst;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
callq 0x20e0
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x30(%rsp), %rsi
addq $0x8, %rsi
movq 0x28(%rsp), %rax
movq (%rax), %rdx
movl 0x1c(%rsp), %ecx
movq 0x28(%rsp), %rax
movl 0x8(%rax), %r8d
movl 0x20(%rsp), %eax
leaq 0x24(%rsp), %r9
movl $0x1, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x3ac0
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/983[P]bigint/bigint.c
// Function: bigint_shift_left
bigint* bigint_shift_left(bigint *dst, const bigint *src, unsigned shift){
    unsigned n = src->size + shift / BIGINT_WORD_BITS + (shift % BIGINT_WORD_BITS != 0);
    bigint_reserve(dst, n);
    dst->size = bigint_raw_shift_left(dst->words, dst->capacity, src->words, src->size, shift);
    return bigint_set_neg(dst, src->neg);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq 0x8(%rsp), %rax
movslq 0xc(%rax), %rax
movl 0x4(%rsp), %ecx
shrq $0x5, %rcx
addq %rcx, %rax
movl 0x4(%rsp), %ecx
andq $0x1f, %rcx
cmpq $0x0, %rcx
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movl %eax, (%rsp)
movq 0x10(%rsp), %rdi
movl (%rsp), %esi
callq 0x20e0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x10(%rax), %esi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rsp), %rax
movl 0xc(%rax), %ecx
movl 0x4(%rsp), %r8d
callq 0x3f20
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x24f0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/983[P]bigint/bigint.c
// Function: bigint_count_trailing_zeros
int bigint_count_trailing_zeros(const bigint *a){
    int i;
    for (i = 0; i < a->size; i++){
        bigint_word w = a->words[i];
        if (w) return bigint_word_count_trailing_zeros(w) + i*BIGINT_WORD_BITS;
    }
    return a->size * BIGINT_WORD_BITS;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x46c3
movq 0x8(%rsp), %rax
movq (%rax), %rax
movslq 0x4(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
je 0x46b4
movl (%rsp), %edi
callq 0x1f30
cltq
movslq 0x4(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl %eax, 0x14(%rsp)
jmp 0x46d4
jmp 0x46b6
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x4671
movq 0x8(%rsp), %rax
movslq 0xc(%rax), %rax
shlq $0x5, %rax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/983[P]bigint/bigint.c
// Function: bigint_div_mod_half_word
bigint* bigint_div_mod_half_word(
    bigint *dst,
    bigint_word *dst_remainder,
    bigint_word denominator
){
    int i, j;
    bigint_word parts[2], div_word, mod_word, remainder = 0;

    BIGINT_ASSERT(denominator, !=, 0);
    BIGINT_ASSERT(denominator, <=, BIGINT_HALF_WORD_MAX);

    for (i = dst->size - 1; i >= 0; i--){
        bigint_word dst_word = 0;
        bigint_word src_word = dst->words[i];
        parts[1] = BIGINT_WORD_LO(src_word);
        parts[0] = BIGINT_WORD_HI(src_word);

        /* divide by denominator twice, keeping remainder in mind */
        for (j = 0; j < 2; j++){
            remainder <<= BIGINT_WORD_BITS / 2;
            remainder |= parts[j];

            div_word = remainder / denominator;
            mod_word = remainder % denominator;
            remainder = mod_word;

            dst_word <<= BIGINT_WORD_BITS / 2;
            dst_word |= div_word;
        }

        dst->words[i] = dst_word;
    }

    *dst_remainder = remainder;
    dst->size = bigint_raw_truncate(dst->words, dst->size);
    return dst;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl $0x0, 0x8(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0x4983
jmp 0x49a2
leaq 0x1c6d(%rip), %rdi      # 0x65f7
leaq 0x1992(%rip), %rsi      # 0x6323
movl $0x366, %edx            # imm = 0x366
leaq 0x1c6f(%rip), %rcx      # 0x660c
callq 0x1070
cmpl $0xffff, 0x24(%rsp)     # imm = 0xFFFF
ja 0x49ae
jmp 0x49cd
leaq 0x1c9e(%rip), %rdi      # 0x6653
leaq 0x1967(%rip), %rsi      # 0x6323
movl $0x367, %edx            # imm = 0x367
leaq 0x1c44(%rip), %rcx      # 0x660c
callq 0x1070
movq 0x30(%rsp), %rax
movl 0xc(%rax), %eax
subl $0x1, %eax
movl %eax, 0x20(%rsp)
cmpl $0x0, 0x20(%rsp)
jl 0x4aaf
movl $0x0, 0x4(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movslq 0x20(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, (%rsp)
movl (%rsp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, 0x18(%rsp)
movl (%rsp), %eax
shrl $0x10, %eax
movl %eax, 0x14(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x2, 0x1c(%rsp)
jge 0x4a8b
movl 0x8(%rsp), %eax
shll $0x10, %eax
movl %eax, 0x8(%rsp)
movslq 0x1c(%rsp), %rax
movl 0x14(%rsp,%rax,4), %eax
orl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
xorl %edx, %edx
divl 0x24(%rsp)
movl %eax, 0x10(%rsp)
movl 0x8(%rsp), %eax
xorl %edx, %edx
divl 0x24(%rsp)
movl %edx, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x4(%rsp), %eax
shll $0x10, %eax
movl %eax, 0x4(%rsp)
movl 0x10(%rsp), %eax
orl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x4a20
movl 0x4(%rsp), %edx
movq 0x30(%rsp), %rax
movq (%rax), %rax
movslq 0x20(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x20(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x49dc
movl 0x8(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x30(%rsp), %rax
movl 0xc(%rax), %esi
callq 0x2640
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/983[P]bigint/bigint.c
// Function: bigint_div
bigint* bigint_div(
    bigint *dst,
    const bigint *numerator,
    const bigint *denominator
){
    bigint unused[1];
    bigint_init(unused);

    bigint_div_mod(dst, unused, numerator, denominator);

    bigint_free(unused);
    return dst;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsp, %rdi
callq 0x20a0
movq 0x30(%rsp), %rdi
movq %rsp, %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x46e0
movq %rsp, %rdi
callq 0x21b0
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/983[P]bigint/bigint.c
// Function: bigint_mod
bigint* bigint_mod(
    bigint *dst,
    const bigint *numerator,
    const bigint *denominator
){
    bigint unused[1];
    bigint_init(unused);

    bigint_div_mod(unused, dst, numerator, denominator);

    bigint_free(unused);
    return dst;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsp, %rdi
callq 0x20a0
movq %rsp, %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x46e0
movq %rsp, %rdi
callq 0x21b0
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/983[P]bigint/bigint.c
// Function: bigint_sqrt
bigint* bigint_sqrt(bigint *dst, const bigint *src){
    int bit;
    bigint sum[1], tmp[1];
    const double MAX_INT_THAT_FITS_IN_DOUBLE = pow(2.0, 52.0);

    dst->neg = 0;
    dst->size = 0;

    if (src->size == 0) return dst;

    if (src->size == 1 && src->words[0] < MAX_INT_THAT_FITS_IN_DOUBLE){
        bigint_from_word(dst, sqrt(src->words[0]));
        return dst;
    }

    bigint_init(sum);
    bigint_init(tmp);

    bigint_cpy(tmp, src);
    tmp->neg = 0;

    /* index of highest 1 bit rounded down */
    bit = bigint_bitlength(src);
    if (bit & 1) bit ^= 1;

    for (; bit >= 0; bit -= 2){
        bigint_cpy(sum, dst);
        bigint_set_bit(sum, bit);

        if (bigint_cmp_abs(tmp, sum) >= 0){
            bigint_sub(tmp, tmp, sum);
            bigint_set_bit(dst, bit + 1);
        }

        bigint_shift_right(dst, dst, 1);
    }

    bigint_free(tmp);
    bigint_free(sum);
    return dst;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movsd 0x14a2(%rip), %xmm0     # 0x62f8
movsd 0x14aa(%rip), %xmm1     # 0x6308
callq 0x1050
movsd %xmm0, 0x8(%rsp)
movq 0x58(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x58(%rsp), %rax
movl $0x0, 0xc(%rax)
movq 0x50(%rsp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x4e9b
movq 0x58(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x4feb
movq 0x50(%rsp), %rax
cmpl $0x1, 0xc(%rax)
jne 0x4efd
movq 0x50(%rsp), %rax
movq (%rax), %rax
movl (%rax), %eax
cvtsi2sd %rax, %xmm1
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4efd
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rax
movl (%rax), %eax
cvtsi2sd %rax, %xmm0
callq 0x10e0
movq (%rsp), %rdi
cvttsd2si %xmm0, %rax
movl %eax, %esi
callq 0x3a60
movq 0x58(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x4feb
leaq 0x30(%rsp), %rdi
callq 0x20a0
leaq 0x10(%rsp), %rdi
callq 0x20a0
leaq 0x10(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x2580
movl $0x0, 0x18(%rsp)
movq 0x50(%rsp), %rdi
callq 0x4640
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4f4d
movl 0x4c(%rsp), %eax
xorl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x4f4f
cmpl $0x0, 0x4c(%rsp)
jl 0x4fcd
leaq 0x30(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x2580
leaq 0x30(%rsp), %rdi
movl 0x4c(%rsp), %esi
callq 0x2730
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x22c0
cmpl $0x0, %eax
jl 0x4fac
leaq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x3de0
movq 0x58(%rsp), %rdi
movl 0x4c(%rsp), %esi
addl $0x1, %esi
callq 0x2730
movq 0x58(%rsp), %rdi
movq 0x58(%rsp), %rsi
movl $0x1, %edx
callq 0x4570
movl 0x4c(%rsp), %eax
subl $0x2, %eax
movl %eax, 0x4c(%rsp)
jmp 0x4f4f
leaq 0x10(%rsp), %rdi
callq 0x21b0
leaq 0x30(%rsp), %rdi
callq 0x21b0
movq 0x58(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/983[P]bigint/bigint.c
// Function: bigint_rand_bits
bigint* bigint_rand_bits(bigint *dst, int n_bits, bigint_rand_func rand_func){
    int n_word_bits = n_bits % BIGINT_WORD_BITS;
    int n_words = n_bits / BIGINT_WORD_BITS + (n_word_bits != 0);

    bigint_reserve(dst, n_words);

    rand_func((uint8_t*)dst->words, sizeof(*dst->words) * n_words);

    if (n_word_bits){
        dst->words[n_words - 1] >>= BIGINT_WORD_BITS - n_word_bits;
    }

    dst->size = bigint_raw_truncate(dst->words, n_words);
    return dst;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movslq 0x1c(%rsp), %rax
andq $0x1f, %rax
movl %eax, 0xc(%rsp)
movslq 0x1c(%rsp), %rax
shrq $0x5, %rax
cmpl $0x0, 0xc(%rsp)
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x20e0
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rdi
movslq 0x8(%rsp), %rcx
shlq $0x2, %rcx
movl %ecx, %esi
callq *%rax
cmpl $0x0, 0xc(%rsp)
je 0x52fe
movslq 0xc(%rsp), %rax
movl $0x20, %ecx
subq %rax, %rcx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x8(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq %rdx, (%rsp)
movl (%rax,%rdx,4), %edx
shrl %cl, %edx
movq (%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movl 0x8(%rsp), %esi
callq 0x2640
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/983[P]bigint/bigint.c
// Function: bigint_rand_inclusive
bigint* bigint_rand_inclusive(
    bigint *dst,
    const bigint *n,
    bigint_rand_func rand_func
){
    int n_bits = bigint_bitlength(n);

    do {
        bigint_rand_bits(dst, n_bits, rand_func);
    } while (bigint_cmp(dst, n) > 0);

    return dst;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4640
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0x5260
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x23d0
cmpl $0x0, %eax
jg 0x5351
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/983[P]bigint/bigint.c
// Function: bigint_rand_exclusive
bigint* bigint_rand_exclusive(
    bigint *dst,
    const bigint *n,
    bigint_rand_func rand_func
){
    int n_bits = bigint_bitlength(n);

    do {
        bigint_rand_bits(dst, n_bits, rand_func);
    } while (bigint_cmp(dst, n) >= 0);

    return dst;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4640
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0x5260
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x23d0
cmpl $0x0, %eax
jge 0x53b1
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/983[P]bigint/bigint.c
// Function: bigint_pow_mod
bigint* bigint_pow_mod(
    bigint *dst,
    const bigint *src_base,
    const bigint *src_exponent,
    const bigint *src_modulus
){
    bigint base[1], exponent[1], tmp[1], unused[1], modulus[1];

    bigint_init(base);
    bigint_init(exponent);
    bigint_init(tmp);
    bigint_init(unused);
    bigint_init(modulus);

    bigint_cpy(exponent, src_exponent);
    bigint_cpy(modulus, src_modulus);
    bigint_div_mod(unused, base, src_base, modulus);
    bigint_from_word(dst, 1);

    for (; exponent->size; bigint_shift_right(exponent, exponent, 1)){
        if (bigint_get_bit(exponent, 0)){
            bigint_mul(tmp, dst, base);
            bigint_div_mod(unused, dst, tmp, modulus);
        }
        bigint_mul(tmp, base, base);
        bigint_div_mod(unused, base, tmp, modulus);
    }

    bigint_free(base);
    bigint_free(exponent);
    bigint_free(tmp);
    bigint_free(unused);
    bigint_free(modulus);
    return dst;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rcx, 0x98(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x20a0
leaq 0x60(%rsp), %rdi
callq 0x20a0
leaq 0x40(%rsp), %rdi
callq 0x20a0
leaq 0x20(%rsp), %rdi
callq 0x20a0
movq %rsp, %rdi
callq 0x20a0
leaq 0x60(%rsp), %rdi
movq 0xa0(%rsp), %rsi
callq 0x2580
movq %rsp, %rdi
movq 0x98(%rsp), %rsi
callq 0x2580
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movq 0xa8(%rsp), %rdx
movq %rsp, %rcx
callq 0x46e0
movq 0xb0(%rsp), %rdi
movl $0x1, %esi
callq 0x3a60
cmpl $0x0, 0x6c(%rsp)
je 0x5538
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0x27e0
cmpl $0x0, %eax
je 0x54eb
leaq 0x40(%rsp), %rdi
movq 0xb0(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x3680
leaq 0x20(%rsp), %rdi
movq 0xb0(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %rsp, %rcx
callq 0x46e0
leaq 0x40(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x3680
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %rsp, %rcx
callq 0x46e0
leaq 0x60(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movl $0x1, %edx
callq 0x4570
jmp 0x549b
leaq 0x80(%rsp), %rdi
callq 0x21b0
leaq 0x60(%rsp), %rdi
callq 0x21b0
leaq 0x40(%rsp), %rdi
callq 0x21b0
leaq 0x20(%rsp), %rdi
callq 0x21b0
movq %rsp, %rdi
callq 0x21b0
movq 0xb0(%rsp), %rax
addq $0xb8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/983[P]bigint/bigint.c
// Function: bigint_pow_word
bigint* bigint_pow_word(bigint *dst, const bigint *base, bigint_word exponent){
    bigint result[1], p[1];

    bigint_init(p);
    bigint_init(result);

    bigint_cpy(p, base);
    bigint_from_word(result, 1);

    for (; exponent; exponent >>= 1){
        if (exponent & 1){
            bigint_mul(result, result, p);
            exponent--;
        }
        bigint_mul(p, p, p);
    }

    bigint_cpy(dst, result);
    bigint_free(p);
    bigint_free(result);
    return dst;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq %rsp, %rdi
callq 0x20a0
leaq 0x20(%rsp), %rdi
callq 0x20a0
movq %rsp, %rdi
movq 0x48(%rsp), %rsi
callq 0x2580
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x3a60
cmpl $0x0, 0x44(%rsp)
je 0x58da
movl 0x44(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x58c0
leaq 0x20(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
callq 0x3680
movl 0x44(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x44(%rsp)
movq %rsp, %rdi
movq %rsp, %rsi
movq %rsp, %rdx
callq 0x3680
movl 0x44(%rsp), %eax
shrl %eax
movl %eax, 0x44(%rsp)
jmp 0x5890
movq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2580
movq %rsp, %rdi
callq 0x21b0
leaq 0x20(%rsp), %rdi
callq 0x21b0
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/983[P]bigint/bigint.c
// Function: bigint_raw_get_high_bits
void bigint_raw_get_high_bits(
    bigint_word *dst, int n_dst,
    const bigint_word *src_a, int na,
    int n_bits,
    int *n_bitlength
){
    int shift;
    *n_bitlength = bigint_raw_bitlength(src_a, na);
    shift = n_bits - *n_bitlength + 1;

    if (shift < 0) bigint_raw_shift_right(dst, n_dst, src_a, na, -shift);
    else           bigint_raw_shift_left (dst, n_dst, src_a, na, +shift);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl %r8d, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x45e0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl 0x18(%rsp), %eax
movq 0x10(%rsp), %rcx
subl (%rcx), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x5981
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
xorl %r8d, %r8d
subl 0xc(%rsp), %r8d
callq 0x4290
jmp 0x599d
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %ecx
movl 0xc(%rsp), %r8d
callq 0x3f20
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/983[P]bigint/bigint.c
// Function: bigint_double
double bigint_double(const bigint *src){
    /* assumes IEEE 754 floating point standard */
    int n, n_mant_bits = 52;
    uint64_t x = 0, exponent = 1023;
    double d;
    bigint_word tmp[20];

    if (src->size == 0) return 0.0;

    bigint_raw_get_high_bits(tmp, 20, src->words, src->size, n_mant_bits, &n);
    /* this bit is stored implicitely */
    bigint_raw_clr_bit(tmp, n_mant_bits);
    exponent--;
    exponent += n;
    memcpy(&x, tmp, sizeof(x));
    x |= exponent << n_mant_bits;

    memcpy(&d, &x, sizeof(d));
    return src->neg ? -d : d;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movl $0x34, 0x80(%rsp)
movq $0x0, 0x78(%rsp)
movq $0x3ff, 0x70(%rsp)      # imm = 0x3FF
movq 0x88(%rsp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x59fb
xorps %xmm0, %xmm0
movsd %xmm0, 0x90(%rsp)
jmp 0x5adc
leaq 0x10(%rsp), %rdi
movq 0x88(%rsp), %rax
movq (%rax), %rdx
movq 0x88(%rsp), %rax
movl 0xc(%rax), %ecx
movl 0x80(%rsp), %r8d
movl $0x14, %esi
leaq 0x84(%rsp), %r9
callq 0x5910
leaq 0x10(%rsp), %rdi
movl 0x80(%rsp), %esi
callq 0x2690
movq 0x70(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x70(%rsp)
movslq 0x84(%rsp), %rax
addq 0x70(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x70(%rsp), %rax
movl 0x80(%rsp), %ecx
shlq %cl, %rax
orq 0x78(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x88(%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0x5ac1
movsd 0x68(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x5acd
movsd 0x68(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x90(%rsp)
movsd 0x90(%rsp), %xmm0
addq $0x98, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSCircularBuffer.c
// Function: eaDSCircularBufferInitWithDetails
eaDSCircularBuffer eaDSCircularBufferInitWithDetails(size_t sizeOfData, void * (*dataCreate)(size_t), void * (*dataCopy)(void *, const void *, size_t), int (*dataCompare)(const void *, const void *, size_t), void (*dataClear)(void *), size_t capacity)
{
	eaDSCircularBuffer circularBuffer = (eaDSCircularBuffer) calloc(1, sizeof(struct _eaDSCircularBuffer));

	if (NULL == circularBuffer)
	{
		perror(NULL);
	}
	else
	{
		circularBuffer->Data = dataCreate(sizeOfData * capacity);

		if (NULL == circularBuffer->Data)
		{
			perror(NULL);
			free(circularBuffer);
			circularBuffer = NULL;
		}
		else
		{
			circularBuffer->Capacity = capacity;
			circularBuffer->SizeOfData = sizeOfData;
			circularBuffer->dataCreate = dataCreate;
			circularBuffer->dataCopy = dataCopy;
			circularBuffer->dataCompare = dataCompare;
			circularBuffer->dataClear = dataClear;
		}
	}

	return circularBuffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x1, %edi
movl $0x50, %esi
callq 0x1060
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq -0x38(%rbp), %rax
jne 0x1279
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
jmp 0x1303
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdi
imulq -0x30(%rbp), %rdi
callq *%rax
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x12b9
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movq -0x38(%rbp), %rdi
callq 0x10e0
movq $0x0, -0x38(%rbp)
jmp 0x1301
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x48(%rax)
jmp 0x1303
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSCircularBuffer.c
// Function: eaDSCircularBufferMoveHead
int eaDSCircularBufferMoveHead(eaDSCircularBuffer circularBuffer, size_t len)
{
	if (circularBuffer->Head + len <= circularBuffer->Tail)
	{
		circularBuffer->Head += len;

		return EXIT_SUCCESS;
	}
	else if ((circularBuffer->Head + len) < circularBuffer->Capacity)
	{
		circularBuffer->Head += len;

		return EXIT_SUCCESS;
	}
	else if(((circularBuffer->Head + len) % circularBuffer->Capacity) < circularBuffer->Tail)
	{
		circularBuffer->Head = (circularBuffer->Head + len) % circularBuffer->Capacity;

		return EXIT_SUCCESS;
	}

	return EXIT_FAILURE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
ja 0x19be
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1a3f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x19ed
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1a3f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x18(%rcx)
movq -0x10(%rbp), %rax
cmpq 0x10(%rax), %rdx
jae 0x1a34
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x18(%rcx)
movq -0x10(%rbp), %rax
movq %rdx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1a3f
jmp 0x1a36
jmp 0x1a38
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSDynamicArray.c
// Function: eaDSDynamicArrayInitWithDetails
int eaDSDynamicArrayInitWithDetails(eaDSDynamicArray * dynamicArray, void * (*dataCreateAndCopy)(const void *), int (*dataCompare)(const void *, const void *), void (*dataClear)(void *), unsigned short expFactor, unsigned short startingCapacity)
{
	if (startingCapacity == 0)
		startingCapacity = DEFAULT_STARTING_CAPACITY;

	dynamicArray->Data = (void **) malloc(startingCapacity * sizeof(void *));

	if (NULL == dynamicArray->Data)
	{
		perror(NULL);
		return EXIT_FAILURE;
	}

	dynamicArray->Count = 0;
	dynamicArray->Capacity = startingCapacity;
	dynamicArray->StartingCapacity = startingCapacity;
	dynamicArray->ExpFactor = (expFactor < 2) ? DEFAULT_EXP_FACTOR : expFactor;
	dynamicArray->dataCreateAndCopy = (NULL == dataCreateAndCopy) ? copyAddress : dataCreateAndCopy;
	dynamicArray->dataCompare = (NULL == dataCompare) ? compareAddress : dataCompare;
	dynamicArray->dataClear = (NULL == dataClear) ? free : dataClear;

	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %r8d, -0x4c(%rbp)
movq %rcx, %rax
movl -0x4c(%rbp), %ecx
movq %rax, -0x48(%rbp)
movq %rdx, %rax
movq -0x48(%rbp), %rdx
movq %rax, -0x40(%rbp)
movq %rsi, %rax
movq -0x40(%rbp), %rsi
movq %rax, -0x38(%rbp)
movq %rdi, %r8
movq -0x38(%rbp), %rdi
movw %r9w, %ax
movq %r8, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movw %cx, -0x2a(%rbp)
movw %ax, -0x2c(%rbp)
movzwl -0x2c(%rbp), %eax
cmpl $0x0, %eax
jne 0x1aee
movw $0x4, -0x2c(%rbp)
movzwl -0x2c(%rbp), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x1090
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x1b27
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movl $0x1, -0x4(%rbp)
jmp 0x1bf7
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movzwl -0x2c(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movw -0x2c(%rbp), %cx
movq -0x10(%rbp), %rax
movw %cx, 0x1a(%rax)
movzwl -0x2a(%rbp), %eax
cmpl $0x2, %eax
jge 0x1b60
movl $0x2, %eax
movl %eax, -0x50(%rbp)
jmp 0x1b67
movzwl -0x2a(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x18(%rax)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x1b8a
leaq 0x7c(%rip), %rax        # 0x1c00
movq %rax, -0x58(%rbp)
jmp 0x1b92
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x1bb3
leaq 0x63(%rip), %rax        # 0x1c10
movq %rax, -0x60(%rbp)
jmp 0x1bbb
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x1bdc
movq 0x53fa(%rip), %rax      # 0x6fd0
movq %rax, -0x68(%rbp)
jmp 0x1be4
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSDynamicArray.c
// Function: eaDSDynamicArrayReset
int eaDSDynamicArrayReset(eaDSDynamicArray * dynamicArray)
{
	if (NULL == dynamicArray->Data)
	{
		dynamicArray->Data = (void **) malloc(dynamicArray->Capacity * sizeof(void *));

		if (NULL == dynamicArray->Data)
		{
			perror(NULL);

			return EXIT_FAILURE;
		}
	}
	else
	{
		while (dynamicArray->Count)
		{
			dynamicArray->dataClear(dynamicArray->Data[--dynamicArray->Count]);
		}

		if (dynamicArray->StartingCapacity < dynamicArray->Capacity)
		{
			free(dynamicArray->Data);
			dynamicArray->Data = (void **) malloc(dynamicArray->StartingCapacity * sizeof(void *));

			if (NULL == dynamicArray->Data)
			{
				perror(NULL);

				return EXIT_FAILURE;
			}

			dynamicArray->Capacity = dynamicArray->StartingCapacity;
		}
	}

	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x1c87
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
shlq $0x3, %rdi
callq 0x1090
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x1c82
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movl $0x1, -0x4(%rbp)
jmp 0x1d32
jmp 0x1d2b
jmp 0x1c89
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1cbf
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x10(%rbp), %rsi
movq 0x8(%rsi), %rdx
movq %rdx, %rdi
addq $-0x1, %rdi
movq %rdi, 0x8(%rsi)
movq -0x8(%rcx,%rdx,8), %rdi
callq *%rax
jmp 0x1c89
movq -0x10(%rbp), %rax
movzwl 0x1a(%rax), %eax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x1d29
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x10e0
movq -0x10(%rbp), %rax
movzwl 0x1a(%rax), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x1090
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x1d17
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movl $0x1, -0x4(%rbp)
jmp 0x1d32
movq -0x10(%rbp), %rax
movzwl 0x1a(%rax), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1d2b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSDynamicArray.c
// Function: eaDSDynamicArrayClear
void eaDSDynamicArrayClear(eaDSDynamicArray * dynamicArray)
{
	if (NULL != dynamicArray->Data)
	{
		while (dynamicArray->Count)
		{
			dynamicArray->dataClear(dynamicArray->Data[--dynamicArray->Count]);
		}

		free(dynamicArray->Data);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x1d9b
jmp 0x1d59
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1d8f
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x8(%rbp), %rsi
movq 0x8(%rsi), %rdx
movq %rdx, %rdi
addq $-0x1, %rdi
movq %rdi, 0x8(%rsi)
movq -0x8(%rcx,%rdx,8), %rdi
callq *%rax
jmp 0x1d59
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x10e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSDynamicArray.c
// Function: eaDSDynamicArraySort
void eaDSDynamicArraySort(eaDSDynamicArray * dynamicArray)
{
	void * buf;
	size_t i, j, N = dynamicArray->Count;

	for (i = 1; i < N; i++)
	{
		for (j = i; (0 < j) && (dynamicArray->dataCompare(dynamicArray->Data[j - 1], dynamicArray->Data[j]) > 0); j--)
		{
			buf = dynamicArray->Data[j];
			dynamicArray->Data[j] = dynamicArray->Data[j - 1];
			dynamicArray->Data[j - 1] = buf;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x1, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x1ea1
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
xorl %ecx, %ecx
cmpq -0x20(%rbp), %rcx
movb %al, -0x29(%rbp)
jae 0x1e28
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x20(%rbp), %rdx
subq $0x1, %rdx
movq (%rcx,%rdx,8), %rdi
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
callq *%rax
cmpl $0x0, %eax
setg %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x1e31
jmp 0x1e8e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1de6
jmp 0x1e90
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1dd0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSDynamicArray.c
// Function: eaDSDynamicArrayAdd
int eaDSDynamicArrayAdd(eaDSDynamicArray * dynamicArray, const void * data)
{
	void * item = dynamicArray->dataCreateAndCopy(data);

	if (NULL == item)
	{
		perror(NULL);

		return EXIT_FAILURE;
	}

	if (dynamicArray->Count == dynamicArray->Capacity)
	{
		void ** tmp;

		dynamicArray->Capacity *= dynamicArray->ExpFactor;
		tmp = (void **) realloc(dynamicArray->Data, dynamicArray->Capacity * sizeof(void *));

		if (NULL == tmp)
		{
			perror(NULL);
			dynamicArray->Capacity /= dynamicArray->ExpFactor;

			return EXIT_FAILURE;
		}

		dynamicArray->Data = tmp;
	}

	dynamicArray->Data[dynamicArray->Count] = item;
	dynamicArray->Count++;

	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x1f2f
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movl $0x1, -0x4(%rbp)
jmp 0x1fed
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x1fbf
movq -0x10(%rbp), %rax
movzwl 0x18(%rax), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
imulq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
shlq $0x3, %rsi
callq 0x10a0
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x1fb4
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movq -0x10(%rbp), %rax
movzwl 0x18(%rax), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rax), %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x1fed
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSDynamicArray.c
// Function: eaDSDynamicArrayInsert
int eaDSDynamicArrayInsert(eaDSDynamicArray * dynamicArray, const void * data, size_t index)
{
	size_t j, cnt = dynamicArray->Count;

	if (index <= cnt)
	{
		void * item;

		if (NULL == (item = dynamicArray->dataCreateAndCopy(data)))
		{
			perror(NULL);

			return EXIT_FAILURE;
		}

		if (dynamicArray->Count == dynamicArray->Capacity)
		{
			void ** tmp;

			dynamicArray->Capacity *= dynamicArray->ExpFactor;
			tmp = (void **) realloc(dynamicArray->Data, dynamicArray->Capacity * sizeof(void *));

			if (NULL == tmp)
			{
				perror(NULL);
				dynamicArray->Capacity /= dynamicArray->ExpFactor;

				return EXIT_FAILURE;
			}

			dynamicArray->Data = tmp;
		}

		if (cnt)
		{
			for (j = cnt - 1; j >= index; j--)
			{
				dynamicArray->Data[j + 1] = dynamicArray->Data[j];

				if (!j)
				{
					break;
				}
			}
		}

		dynamicArray->Data[index] = item;
		dynamicArray->Count++;

		return EXIT_SUCCESS;
	}

	return EXIT_FAILURE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
ja 0x2179
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq %rax, %rcx
movq %rcx, -0x38(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x205f
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movl $0x1, -0x4(%rbp)
jmp 0x2180
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x20f6
movq -0x10(%rbp), %rax
movzwl 0x18(%rax), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
imulq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
shlq $0x3, %rsi
callq 0x10a0
movq %rax, -0x40(%rbp)
xorl %eax, %eax
cmpq -0x40(%rbp), %rax
jne 0x20eb
xorl %eax, %eax
movl %eax, %edi
callq 0x10b0
movq -0x10(%rbp), %rax
movzwl 0x18(%rax), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x10(%rax), %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x2180
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x214d
movq -0x30(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x214b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
cmpq $0x0, -0x28(%rbp)
jne 0x213b
jmp 0x214b
jmp 0x213d
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2109
jmp 0x214d
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x2180
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Enes1313[P]DataStructures/DS/eaDSDynamicArray.c
// Function: eaDSDynamicArrayRemove
void eaDSDynamicArrayRemove(eaDSDynamicArray * dynamicArray, const void * data)
{
	size_t i, cnt = dynamicArray->Count;

	for (i = 0; i < cnt; i++)
	{
		if (!dynamicArray->dataCompare(data, dynamicArray->Data[i]))
		{
			if ((DEFAULT_STARTING_CAPACITY < dynamicArray->Capacity) && (dynamicArray->Count < dynamicArray->Capacity / dynamicArray->ExpFactor))
			{
				void ** tmp;

				dynamicArray->Capacity /= dynamicArray->ExpFactor;
				tmp = (void **) realloc(dynamicArray->Data, dynamicArray->Capacity * sizeof(void *));

				if (NULL != tmp)
				{
					dynamicArray->Data = tmp;
				}
				else
				{
					dynamicArray->Capacity *= dynamicArray->ExpFactor;
				}
				
			}

			dynamicArray->Count--;
			dynamicArray->dataClear(dynamicArray->Data[i]);

			for (; i < (cnt - 1); i++)
			{
				dynamicArray->Data[i] = dynamicArray->Data[i + 1];
			}

			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x2314
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x2301
movq -0x8(%rbp), %rcx
movl $0x4, %eax
cmpq 0x10(%rcx), %rax
jae 0x2298
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movzwl 0x18(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x2298
movq -0x8(%rbp), %rax
movzwl 0x18(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x10(%rax), %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
shlq $0x3, %rsi
callq 0x10a0
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
je 0x227f
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x2296
movq -0x8(%rbp), %rax
movzwl 0x18(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
imulq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
jmp 0x2298
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
callq *%rax
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x22ff
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x22c1
jmp 0x2314
jmp 0x2303
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x21b4
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)