LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: uECC_compute_public_key
int uECC_compute_public_key(const uint8_t *private_key, uint8_t *public_key, uECC_Curve curve) {
#if uECC_VLI_NATIVE_LITTLE_ENDIAN
    uECC_word_t *_private = (uECC_word_t *)private_key;
    uECC_word_t *_public = (uECC_word_t *)public_key;
#else
    uECC_word_t _private[uECC_MAX_WORDS];
    uECC_word_t _public[uECC_MAX_WORDS * 2];
#endif

#if uECC_VLI_NATIVE_LITTLE_ENDIAN == 0
    uECC_vli_bytesToNative(_private, private_key, BITS_TO_BYTES(curve->num_n_bits));
#endif

    /* Make sure the private key is in the range [1, n-1]. */
    if (uECC_vli_isZero(_private, BITS_TO_WORDS(curve->num_n_bits))) {
        return 0;
    }

    if (uECC_vli_cmp(curve->n, _private, BITS_TO_WORDS(curve->num_n_bits)) != 1) {
        return 0;
    }

    /* Compute public key. */
    if (!EccPoint_compute_public_key(_public, _private, curve)) {
        return 0;
    }

#if uECC_VLI_NATIVE_LITTLE_ENDIAN == 0
    uECC_vli_nativeToBytes(public_key, curve->num_bytes, _public);
    uECC_vli_nativeToBytes(
        public_key + curve->num_bytes, curve->num_bytes, _public + curve->num_words);
#endif
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %rsi
movswl 0x2(%rdx), %r15d
leal 0x7(%r15), %eax
pushq $0x8
popq %rcx
cltd
idivl %ecx
movq %rsp, %r12
movq %r12, %rdi
movl %eax, %edx
callq 0x19d5
addl $0x3f, %r15d
pushq $0x40
popq %rcx
movl %r15d, %eax
cltd
idivl %ecx
movsbl %al, %r15d
movq %r12, %rdi
movl %r15d, %esi
callq 0x1d5d
xorl %ebp, %ebp
testq %rax, %rax
jne 0x2087
leaq 0x28(%r14), %rdi
movq %rsp, %rsi
movl %r15d, %edx
callq 0x2096
cmpb $0x1, %al
jne 0x2087
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movq %r14, %rdx
callq 0x181a
testq %rax, %rax
je 0x2087
movsbl 0x1(%r14), %esi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x1887
movsbq 0x1(%r14), %rsi
addq %rsi, %rbx
movsbq (%r14), %rax
leaq (%rsp,%rax,8), %rdx
addq $0x20, %rdx
movq %rbx, %rdi
callq 0x1887
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: uECC_vli_cmp(unsigned long const*, unsigned long const*, signed char)
uECC_VLI_API cmpresult_t uECC_vli_cmp(const uECC_word_t *left,
                                      const uECC_word_t *right,
                                      wordcount_t num_words) {
    uECC_word_t tmp[uECC_MAX_WORDS];
    uECC_word_t neg = !!uECC_vli_sub(tmp, left, right, num_words);
    uECC_word_t equal = uECC_vli_isZero(tmp, num_words);
    return (!equal - 2 * neg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movq %rsi, %rdx
movq %rdi, %rsi
movq %rsp, %r14
movq %r14, %rdi
movl %ebx, %ecx
callq 0x1e48
movq %rax, %r15
movq %r14, %rdi
movl %ebx, %esi
callq 0x1d5d
xorl $0x1, %eax
addl %r15d, %r15d
subl %r15d, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: uECC_sign
int uECC_sign(const uint8_t *private_key,
              const uint8_t *message_hash,
              unsigned hash_size,
              uint8_t *signature,
              uECC_Curve curve) {
    uECC_word_t k[uECC_MAX_WORDS];
    uECC_word_t tries;

    for (tries = 0; tries < uECC_RNG_MAX_TRIES; ++tries) {
        if (!uECC_generate_random_int(k, curve->n, BITS_TO_WORDS(curve->num_n_bits))) {
            return 0;
        }

        if (uECC_sign_with_k(private_key, message_hash, hash_size, k, signature, curve)) {
            return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %rbx
movq %rcx, 0x18(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, %r12
leaq 0x28(%r8), %r13
pushq $0x41
popq %r15
leaq 0x20(%rsp), %r14
xorl %ebp, %ebp
decq %r15
je 0x214c
movswl 0x2(%rbx), %eax
addl $0x3f, %eax
cltd
pushq $0x40
popq %rcx
idivl %ecx
movsbl %al, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1776
testl %eax, %eax
je 0x214c
movq %r12, %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
movq %r14, %rcx
movq 0x18(%rsp), %r8
movq %rbx, %r9
callq 0x215d
testl %eax, %eax
je 0x2105
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: HMAC_init(uECC_HashContext const*, unsigned char const*)
static void HMAC_init(const uECC_HashContext *hash_context, const uint8_t *K) {
    uint8_t *pad = hash_context->tmp + 2 * hash_context->result_size;
    unsigned i;
    for (i = 0; i < hash_context->result_size; ++i)
        pad[i] = K[i] ^ 0x36;
    for (; i < hash_context->block_size; ++i)
        pad[i] = 0x36;

    hash_context->init_hash(hash_context);
    hash_context->update_hash(hash_context, pad, hash_context->block_size);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x1c(%rdi), %ecx
leal (%rcx,%rcx), %r14d
addq 0x20(%rdi), %r14
xorl %eax, %eax
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x262d
movb (%rsi,%rax), %cl
xorb $0x36, %cl
movb %cl, (%r14,%rax)
incq %rax
movl 0x1c(%rbx), %ecx
jmp 0x260c
movb $0x36, (%r14,%rax)
incq %rax
movl 0x18(%rbx), %ecx
cmpq %rcx, %rax
jb 0x2625
movq %rbx, %rdi
callq *(%rbx)
movq 0x8(%rbx), %rax
movl 0x18(%rbx), %edx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: HMAC_finish(uECC_HashContext const*, unsigned char const*, unsigned char*)
static void HMAC_finish(const uECC_HashContext *hash_context,
                        const uint8_t *K,
                        uint8_t *result) {
    uint8_t *pad = hash_context->tmp + 2 * hash_context->result_size;
    unsigned i;
    for (i = 0; i < hash_context->result_size; ++i)
        pad[i] = K[i] ^ 0x5c;
    for (; i < hash_context->block_size; ++i)
        pad[i] = 0x5c;

    hash_context->finish_hash(hash_context, result);

    hash_context->init_hash(hash_context);
    hash_context->update_hash(hash_context, pad, hash_context->block_size);
    hash_context->update_hash(hash_context, result, hash_context->result_size);
    hash_context->finish_hash(hash_context, result);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movl 0x1c(%rdi), %ecx
leal (%rcx,%rcx), %r15d
addq 0x20(%rdi), %r15
xorl %eax, %eax
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x268a
movb (%rsi,%rax), %cl
xorb $0x5c, %cl
movb %cl, (%r15,%rax)
incq %rax
movl 0x1c(%r14), %ecx
jmp 0x2668
movb $0x5c, (%r15,%rax)
incq %rax
movl 0x18(%r14), %ecx
cmpq %rcx, %rax
jb 0x2682
movq %r14, %rdi
movq %rbx, %rsi
callq *0x10(%r14)
movq %r14, %rdi
callq *(%r14)
movl 0x18(%r14), %edx
movq %r14, %rdi
movq %r15, %rsi
callq *0x8(%r14)
movl 0x1c(%r14), %edx
movq %r14, %rdi
movq %rbx, %rsi
callq *0x8(%r14)
movq 0x10(%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: bits2int(unsigned long*, unsigned char const*, unsigned int, uECC_Curve_t const*)
static void bits2int(uECC_word_t *native,
                     const uint8_t *bits,
                     unsigned bits_size,
                     uECC_Curve curve) {
    unsigned num_n_bytes = BITS_TO_BYTES(curve->num_n_bits);
    unsigned num_n_words = BITS_TO_WORDS(curve->num_n_bits);
    int shift;
    uECC_word_t carry;
    uECC_word_t *ptr;

    if (bits_size > num_n_bytes) {
        bits_size = num_n_bytes;
    }

    uECC_vli_clear(native, num_n_words);
#if uECC_VLI_NATIVE_LITTLE_ENDIAN
    bcopy((uint8_t *) native, bits, bits_size);
#else
    uECC_vli_bytesToNative(native, bits, bits_size);
#endif    
    if (bits_size * 8 <= (unsigned)curve->num_n_bits) {
        return;
    }
    shift = bits_size * 8 - curve->num_n_bits;
    carry = 0;
    ptr = native + num_n_words;
    while (ptr-- > native) {
        uECC_word_t temp = *ptr;
        *ptr = (temp >> shift) | carry;
        carry = temp << (uECC_WORD_BITS - shift);
    }

    /* Reduce mod curve_n */
    if (uECC_vli_cmp_unsafe(curve->n, native, num_n_words) != 1) {
        uECC_vli_sub(native, native, curve->n, num_n_words);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r15d
movq %rsi, (%rsp)
movq %rdi, %r14
movswl 0x2(%rcx), %ecx
leal 0x7(%rcx), %eax
pushq $0x8
popq %rsi
cltd
idivl %esi
movl %eax, %esi
addl $0x3f, %ecx
pushq $0x40
popq %r12
movl %ecx, %eax
cltd
idivl %r12d
movl %eax, %ebp
cmpl %r15d, %esi
cmovbl %esi, %r15d
movsbl %bpl, %r13d
movl %r13d, %esi
callq 0x3272
movq %r14, %rdi
movq (%rsp), %rsi
movl %r15d, %edx
callq 0x19d5
shll $0x3, %r15d
movswl 0x2(%rbx), %eax
subl %eax, %r15d
jbe 0x2e54
movl %ebp, %eax
leaq (%r14,%rax,8), %rax
subl %r15d, %r12d
xorl %edx, %edx
cmpq %r14, %rax
jbe 0x2e3e
movq -0x8(%rax), %rsi
movq %rsi, %rdi
movl %r15d, %ecx
shrq %cl, %rdi
orq %rdx, %rdi
movl %r12d, %ecx
shlq %cl, %rsi
movq %rdi, -0x8(%rax)
addq $-0x8, %rax
movq %rsi, %rdx
jmp 0x2e16
addq $0x28, %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0x1f1e
cmpb $0x1, %al
jne 0x2e63
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %r13d, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1e48
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: uECC_vli_modSub(unsigned long*, unsigned long const*, unsigned long const*, unsigned long const*, signed char)
uECC_VLI_API void uECC_vli_modSub(uECC_word_t *result,
                                  const uECC_word_t *left,
                                  const uECC_word_t *right,
                                  const uECC_word_t *mod,
                                  wordcount_t num_words) {
    uECC_word_t l_borrow = uECC_vli_sub(result, left, right, num_words);
    if (l_borrow) {
        /* In this case, result == -diff == (max int) - diff. Since -x % d == d - x,
           we can get the correct result from result + mod (with overflow). */
        uECC_vli_add(result, result, mod, num_words);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdi, %r14
movl %r8d, %ecx
callq 0x1e48
testq %rax, %rax
je 0x3064
movsbl %bpl, %ecx
movq %r14, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x3763
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: XYcZ_add(unsigned long*, unsigned long*, unsigned long*, unsigned long*, uECC_Curve_t const*)
static void XYcZ_add(uECC_word_t * X1,
                     uECC_word_t * Y1,
                     uECC_word_t * X2,
                     uECC_word_t * Y2,
                     uECC_Curve curve) {
    /* t1 = X1, t2 = Y1, t3 = X2, t4 = Y2 */
    uECC_word_t t5[uECC_MAX_WORDS];
    wordcount_t num_words = curve->num_words;

    uECC_vli_modSub(t5, X2, X1, curve->p, num_words); /* t5 = x2 - x1 */
    uECC_vli_modSquare_fast(t5, t5, curve);                  /* t5 = (x2 - x1)^2 = A */
    uECC_vli_modMult_fast(X1, X1, t5, curve);                /* t1 = x1*A = B */
    uECC_vli_modMult_fast(X2, X2, t5, curve);                /* t3 = x2*A = C */
    uECC_vli_modSub(Y2, Y2, Y1, curve->p, num_words); /* t4 = y2 - y1 */
    uECC_vli_modSquare_fast(t5, Y2, curve);                  /* t5 = (y2 - y1)^2 = D */

    uECC_vli_modSub(t5, t5, X1, curve->p, num_words); /* t5 = D - B */
    uECC_vli_modSub(t5, t5, X2, curve->p, num_words); /* t5 = D - B - C = x3 */
    uECC_vli_modSub(X2, X2, X1, curve->p, num_words); /* t3 = C - B */
    uECC_vli_modMult_fast(Y1, Y1, X2, curve);                /* t2 = y1*(C - B) */
    uECC_vli_modSub(X2, X1, t5, curve->p, num_words); /* t3 = B - x3 */
    uECC_vli_modMult_fast(Y2, Y2, X2, curve);                /* t4 = (y2 - y1)*(B - x3) */
    uECC_vli_modSub(Y2, Y2, Y1, curve->p, num_words); /* t4 = y3 */

    uECC_vli_set(X2, t5, num_words);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r12
movq %rcx, (%rsp)
movq %rdx, %rbx
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
movsbl (%r8), %ebp
leaq 0x8(%r8), %r13
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %r14, %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x3034
movq %r15, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1f4e
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x328d
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x328d
movq (%rsp), %r15
movq %r15, %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x3034
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1f4e
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movq %rdi, %r15
movq %r14, %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x3034
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x3034
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x3034
movq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x328d
movq %rbx, %rdi
movq %r14, %rsi
leaq 0x10(%rsp), %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x3034
movq (%rsp), %r14
movq %r14, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x328d
movq %r14, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x3034
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
movl %ebp, %edx
callq 0x3017
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: apply_z(unsigned long*, unsigned long*, unsigned long const*, uECC_Curve_t const*)
static void apply_z(uECC_word_t * X1,
                    uECC_word_t * Y1,
                    const uECC_word_t * const Z,
                    uECC_Curve curve) {
    uECC_word_t t1[uECC_MAX_WORDS];

    uECC_vli_modSquare_fast(t1, Z, curve);    /* z^2 */
    uECC_vli_modMult_fast(X1, X1, t1, curve); /* x1 * z^2 */
    uECC_vli_modMult_fast(t1, t1, Z, curve);  /* z^3 */
    uECC_vli_modMult_fast(Y1, Y1, t1, curve); /* y1 * z^3 */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x1f4e
movq %r12, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x328d
movq %r13, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x328d
movq %r15, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x328d
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: uECC_vli_numBits(unsigned long const*, signed char)
static wordcount_t vli_numDigits(const uECC_word_t *vli, const wordcount_t max_words) {
    wordcount_t i;
    /* Search from the end until we find a non-zero digit.
       We do it in reverse because we expect that most digits will be nonzero. */
    for (i = max_words - 1; i >= 0 && vli[i] == 0; --i) {
    }

    return (i + 1);
}

// Assembly:
movzbl %sil, %edx
shll $0x18, %esi
movq %rdx, %rax
movl %esi, %ecx
decq %rdx
testb %dl, %dl
js 0x324a
movl %edx, %r8d
andl $0x7f, %r8d
leal -0x1000000(%rcx), %esi
cmpq $0x0, (%rdi,%r8,8)
je 0x322a
testq %rax, %rax
je 0x326f
sarl $0x18, %ecx
movslq %ecx, %rcx
movq -0x8(%rdi,%rcx,8), %rcx
movsbl %al, %eax
shll $0x6, %eax
addl $-0x40, %eax
testq %rcx, %rcx
je 0x3271
shrq %rcx
incl %eax
jmp 0x3263
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: uECC_vli_modAdd(unsigned long*, unsigned long const*, unsigned long const*, unsigned long const*, signed char)
uECC_VLI_API void uECC_vli_modAdd(uECC_word_t *result,
                                  const uECC_word_t *left,
                                  const uECC_word_t *right,
                                  const uECC_word_t *mod,
                                  wordcount_t num_words) {
    uECC_word_t carry = uECC_vli_add(result, left, right, num_words);
    if (carry || uECC_vli_cmp_unsafe(mod, result, num_words) != 1) {
        /* result > mod (result = mod + remainder), so subtract mod to get remainder. */
        uECC_vli_sub(result, result, mod, num_words);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdi, %r14
movl %r8d, %ecx
callq 0x3763
movsbl %bpl, %ebp
testq %rax, %rax
jne 0x374f
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x1f1e
cmpb $0x1, %al
jne 0x374f
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
popq %rbx
popq %r14
popq %rbp
jmp 0x1e48
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: uECC_vli_add(unsigned long*, unsigned long const*, unsigned long const*, signed char)
uECC_VLI_API uECC_word_t uECC_vli_add(uECC_word_t *result,
                                      const uECC_word_t *left,
                                      const uECC_word_t *right,
                                      wordcount_t num_words) {
    uECC_word_t carry = 0;
    wordcount_t i;
    for (i = 0; i < num_words; ++i) {
        uECC_word_t sum = left[i] + right[i] + carry;
        if (sum != left[i]) {
            carry = (sum < left[i]);
        }
        result[i] = sum;
    }
    return carry;
}

// Assembly:
xorl %r8d, %r8d
testb %cl, %cl
cmovlel %r8d, %ecx
movslq %ecx, %rcx
xorl %eax, %eax
cmpq %r8, %rcx
je 0x3799
movq (%rsi,%r8,8), %r9
leaq (%r9,%rax), %r10
addq (%rdx,%r8,8), %r10
xorl %r11d, %r11d
cmpq %r9, %r10
setb %r11b
cmovneq %r11, %rax
movq %r10, (%rdi,%r8,8)
incq %r8
jmp 0x3771
retq
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: uECC_vli_rshift1(unsigned long*, signed char)
uECC_VLI_API void uECC_vli_rshift1(uECC_word_t *vli, wordcount_t num_words) {
    uECC_word_t *end = vli;
    uECC_word_t carry = 0;

    vli += num_words;
    while (vli-- > end) {
        uECC_word_t temp = *vli;
        *vli = (temp >> 1) | carry;
        carry = temp << (uECC_WORD_BITS - 1);
    }
}

// Assembly:
movslq %esi, %rax
leaq (%rdi,%rax,8), %rax
xorl %ecx, %ecx
cmpq %rdi, %rax
jbe 0x37c6
movq -0x8(%rax), %rdx
movq %rdx, %rsi
shrq %rsi
orq %rcx, %rsi
movq %rsi, -0x8(%rax)
addq $-0x8, %rax
shlq $0x3f, %rdx
movq %rdx, %rcx
jmp 0x37a3
retq
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: vli_modInv_update(unsigned long*, unsigned long const*, signed char)
static void vli_modInv_update(uECC_word_t *uv,
                              const uECC_word_t *mod,
                              wordcount_t num_words) {
    uECC_word_t carry = 0;
    if (!EVEN(uv)) {
        carry = uECC_vli_add(uv, uv, mod, num_words);
    }
    uECC_vli_rshift1(uv, num_words);
    if (carry) {
        uv[num_words - 1] |= HIGH_BIT_SET;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
testb $0x1, (%rdi)
jne 0x461f
movsbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x379a
movq %rsi, %rdx
movsbl %bpl, %r14d
movq %rbx, %rdi
movq %rbx, %rsi
movl %r14d, %ecx
callq 0x3763
movq %rax, %r15
movq %rbx, %rdi
movl %r14d, %esi
callq 0x379a
testq %r15, %r15
je 0x4650
movsbq %bpl, %rax
orb $-0x80, -0x1(%rbx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: uECC_vli_mult(unsigned long*, unsigned long const*, unsigned long const*, signed char)
uECC_VLI_API void uECC_vli_mult(uECC_word_t *result,
                                const uECC_word_t *left,
                                const uECC_word_t *right,
                                wordcount_t num_words) {
    uECC_word_t r0 = 0;
    uECC_word_t r1 = 0;
    uECC_word_t r2 = 0;
    wordcount_t i, k;

    /* Compute each digit of result in sequence, maintaining the carries. */
    for (k = 0; k < num_words; ++k) {
        for (i = 0; i <= k; ++i) {
            muladd(left[i], right[k - i], &r0, &r1, &r2);
        }
        result[k] = r0;
        r0 = r1;
        r1 = r2;
        r2 = 0;
    }
    for (k = num_words; k < num_words * 2 - 1; ++k) {
        for (i = (k + 1) - num_words; i < num_words; ++i) {
            muladd(left[i], right[k - i], &r0, &r1, &r2);
        }
        result[k] = r0;
        r0 = r1;
        r1 = r2;
        r2 = 0;
    }
    result[num_words * 2 - 1] = r0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
leaq 0x10(%rsp), %rax
andq $0x0, (%rax)
leaq 0x20(%rsp), %r13
andq $0x0, (%r13)
leaq 0x18(%rsp), %rbp
andq $0x0, (%rbp)
movq %rdi, 0x38(%rsp)
xorl %eax, %eax
testb %cl, %cl
movl %ecx, 0xc(%rsp)
cmovlel %eax, %ecx
movslq %ecx, %rcx
movq %rcx, 0x30(%rsp)
xorl %ebx, %ebx
cmpq 0x30(%rsp), %rbx
je 0x4706
xorl %r12d, %r12d
movsbq %r12b, %r12
movq %rbx, %rax
subq %r12, %rax
jl 0x46d9
movq (%r15,%r12,8), %rdi
movq (%r14,%rax,8), %rsi
leaq 0x10(%rsp), %rdx
movq %r13, %rcx
movq %rbp, %r8
callq 0x4404
incb %r12b
jmp 0x46b0
movq 0x10(%rsp), %rax
movq 0x38(%rsp), %rcx
movq %rax, (%rcx,%rbx,8)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rsp)
andq $0x0, 0x18(%rsp)
incq %rbx
jmp 0x46a6
movl 0xc(%rsp), %edx
movsbl %dl, %ecx
leal -0x1(,%rcx,2), %ecx
movl %ecx, 0x2c(%rsp)
movsbq %dl, %rbx
movb $0x1, %sil
leaq 0x18(%rsp), %r12
movsbl %dl, %ecx
cmpl %ecx, 0x2c(%rsp)
jle 0x47c5
movl %edx, 0xc(%rsp)
movsbq %dl, %rax
movq %rax, 0x40(%rsp)
leaq (,%rax,8), %r13
movb %sil, 0x30(%rsp)
movsbq %sil, %rbp
leaq (,%rbp,8), %rax
subq %rax, %r13
addq %r14, %r13
cmpq %rbx, %rbp
jge 0x4785
movq (%r15,%rbp,8), %rdi
movq (%r13), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x20(%rsp), %rcx
movq %r12, %r8
callq 0x4404
incq %rbp
addq $-0x8, %r13
jmp 0x475d
movl 0xc(%rsp), %edx
incb %dl
movq 0x10(%rsp), %rax
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %rsi
movq %rax, (%rcx,%rsi,8)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rsp)
andq $0x0, 0x18(%rsp)
movb 0x30(%rsp), %sil
incb %sil
jmp 0x4724
movslq 0x2c(%rsp), %rcx
movq 0x38(%rsp), %rdx
movq %rax, (%rdx,%rcx,8)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/SHA256.cpp
// Function: SHA256::update(void const*, unsigned long)
void SHA256::update(const void *data, size_t len)
{
    // Update the total length (in bits, not bytes).
    state.length += ((uint64_t)len) << 3;

    // Break the input up into 512-bit chunks and process each in turn.
    const uint8_t *d = (const uint8_t *)data;
    while (len > 0) {
        uint8_t size = 64 - state.chunkSize;
        if (size > len)
            size = len;
        memcpy(((uint8_t *)state.w) + state.chunkSize, d, size);
        state.chunkSize += size;
        len -= size;
        d += size;
        if (state.chunkSize == 64) {
            processChunk();
            state.chunkSize = 0;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq (,%rdx,8), %rax
addq %rax, 0x68(%rdi)
leaq 0x28(%rdi), %r13
testq %rbx, %rbx
je 0x48c2
movzbl 0x70(%r15), %edi
movb $0x40, %al
subb %dil, %al
movzbl %al, %eax
cmpq %rax, %rbx
movl %ebx, %ecx
cmovael %eax, %ecx
addq %r13, %rdi
movzbl %cl, %r12d
movq %r14, %rsi
movq %r12, %rdx
callq 0x1090
movl %r12d, %eax
addb 0x70(%r15), %al
movb %al, 0x70(%r15)
subq %r12, %rbx
addq %r12, %r14
cmpb $0x40, %al
jne 0x4872
movq %r15, %rdi
callq 0x48cc
movb $0x0, 0x70(%r15)
jmp 0x4872
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/SHA256.cpp
// Function: SHA256::finalize(void*, unsigned long)
void SHA256::finalize(void *hash, size_t len)
{
    // Pad the last chunk.  We may need two padding chunks if there
    // isn't enough room in the first for the padding and length.
    uint8_t *wbytes = (uint8_t *)state.w;
    if (state.chunkSize <= (64 - 9)) {
        wbytes[state.chunkSize] = 0x80;
        memset(wbytes + state.chunkSize + 1, 0x00, 64 - 8 - (state.chunkSize + 1));
        state.w[14] = htobe32((uint32_t)(state.length >> 32));
        state.w[15] = htobe32((uint32_t)state.length);
        processChunk();
    } else {
        wbytes[state.chunkSize] = 0x80;
        memset(wbytes + state.chunkSize + 1, 0x00, 64 - (state.chunkSize + 1));
        processChunk();
        memset(wbytes, 0x00, 64 - 8);
        state.w[14] = htobe32((uint32_t)(state.length >> 32));
        state.w[15] = htobe32((uint32_t)state.length);
        processChunk();
    }

    // Convert the result into big endian and return it.
    for (uint8_t posn = 0; posn < 8; ++posn)
        state.w[posn] = htobe32(state.h[posn]);

    // Copy the hash to the caller's return buffer.
    if (len > 32)
        len = 32;
    memcpy(hash, state.w, len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x28(%rdi), %r15
movzbl 0x70(%rdi), %ecx
movb $-0x80, 0x28(%rdi,%rcx)
movzbl 0x70(%rdi), %eax
addq %rax, %rdi
addq $0x29, %rdi
cmpq $0x37, %rcx
ja 0x4b5a
pushq $0x37
popq %rdx
subq %rax, %rdx
xorl %esi, %esi
callq 0x1070
jmp 0x4b85
pushq $0x3f
popq %rdx
subq %rax, %rdx
xorl %esi, %esi
callq 0x1070
movq %r12, %rdi
callq 0x48cc
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r15)
movups %xmm0, 0x10(%r15)
movups %xmm0, (%r15)
andq $0x0, 0x30(%r15)
movq 0x68(%r12), %rax
movq %rax, %rcx
shrq $0x20, %rcx
movq %rax, %rdx
shrq $0x38, %rdx
movq %rax, %rsi
shrq $0x28, %rsi
andl $0xff00, %esi           # imm = 0xFF00
movl %ecx, %edi
shll $0x8, %edi
andl $0xff0000, %edi         # imm = 0xFF0000
shll $0x18, %ecx
orl %edx, %ecx
orl %esi, %ecx
orl %edi, %ecx
movl %ecx, 0x60(%r12)
bswapl %eax
movl %eax, 0x64(%r12)
movq %r12, %rdi
callq 0x48cc
pushq $-0x20
popq %rax
testq %rax, %rax
je 0x4be6
movl (%r15,%rax), %ecx
bswapl %ecx
movl %ecx, 0x20(%r15,%rax)
addq $0x4, %rax
jmp 0x4bd0
cmpq $0x20, %r14
pushq $0x20
popq %rdx
cmovbq %r14, %rdx
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1090
nop
// File: /workspace/github_cpp_makefile_star2_O2/pstuifzand[P]magento-tools/src/block-lister.cpp
// Function: parse_xml(xml_parser&, std::basic_ifstream<char, std::char_traits<char>>&, user_data*)
void parse_xml(xml_parser& parser, std::ifstream& in, user_data* data) {
    const int size = 1024;
    char buf[size];
    while (in) {
        in.read(buf, size);
        XML_Status ret = XML_Parse(parser.handle(), buf, in.gcount(), in ? 0 : 1);
        if (!ret) {
            XML_Error error = XML_GetErrorCode(parser.handle());
            int line = XML_GetCurrentLineNumber(parser.handle());
            std::cerr << data->filename << ":" << line << ": error: " << XML_ErrorString(error) << "\n";
            break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %r12
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r15,%rax)
jne 0x1614
movl $0x400, %edx            # imm = 0x400
movq %r15, %rdi
movq %r12, %rsi
callq 0x1110
movq (%r14), %rdi
movl 0x8(%r15), %edx
movq (%r15), %rax
movq -0x18(%rax), %rax
xorl %ecx, %ecx
testb $0x5, 0x20(%r15,%rax)
setne %cl
movq %r12, %rsi
callq 0x1180
testl %eax, %eax
jne 0x155b
movq (%r14), %rdi
callq 0x1120
movl %eax, %ebp
movq (%r14), %rdi
callq 0x1090
movq %rax, %r14
movq (%rbx), %rsi
movq 0x2a2e(%rip), %rdi      # 0x3ff0
callq 0x10e0
leaq 0xa8a(%rip), %rsi       # 0x2058
movq %rax, %rdi
callq 0x10e0
movq %rax, %rdi
movl %r14d, %esi
callq 0x1150
leaq 0xa72(%rip), %rsi       # 0x205a
movq %rax, %rdi
callq 0x10e0
movq %rax, %rbx
movl %ebp, %edi
callq 0x1030
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10e0
leaq 0xa30(%rip), %rsi       # 0x203c
movq %rax, %rdi
callq 0x10e0
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pstuifzand[P]magento-tools/src/block-lister.cpp
// Function: main
int main(int argc, char** argv)
{
    // remove program name
    argc--;
    argv++;

    // no arguments
    if (!argc) return 0;

    // create parser
    xml_parser parser;

    while (argc) {
        user_data data;
        data.in_action = 0;
        data.filename = *argv;

        XML_SetUserData(parser.handle(), &data);
        XML_SetElementHandler(parser.handle(), root_start_element_handler, root_end_element_handler);
        XML_SetCharacterDataHandler(parser.handle(), character_data_handler);

        std::ifstream in{data.filename};
        if (in) parse_xml(parser, in, &data);
        parser.reset();

        argc--;
        argv++;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
cmpl $0x1, %edi
je 0x16ff
movq %rsi, %rbx
movl %edi, %ebp
xorl %edi, %edi
callq 0x1160
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movl %ebp, %ebp
pushq $0x1
popq %r13
leaq 0x10(%rsp), %r15
leaq 0x20(%rsp), %r12
cmpl %r13d, %ebp
je 0x16f5
andl $0x0, 0x18(%rsp)
movq (%rbx,%r13,8), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1040
movq 0x8(%rsp), %rdi
leaq -0x3b6(%rip), %rsi      # 0x12dc
leaq -0x17a(%rip), %rdx      # 0x151f
callq 0x10d0
movq 0x8(%rsp), %rdi
leaq -0x16b(%rip), %rsi      # 0x153f
callq 0x1100
movq 0x10(%rsp), %rsi
movq %r12, %rdi
pushq $0x8
popq %rdx
callq 0x1190
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x16dd
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1540
movq %r14, %rdi
callq 0x1762
movq %r12, %rdi
callq 0x1050
incq %r13
jmp 0x1662
leaq 0x8(%rsp), %rdi
callq 0x176c
xorl %eax, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1724
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1050
jmp 0x1727
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x176c
movq %rbx, %rdi
callq 0x1170
nop
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day03/ex01/FragTrap.cpp
// Function: FragTrap::FragTrap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
FragTrap::FragTrap(std::string name)
{
	this->hitPoints = 100;
	this->maxHit = 100;
	this->energyPoints = 100;
	this->maxEnergyPoints = 100;
	this->name = name;
	this->meleeAttackDamage = 30;
	this->rangedAttackDamage = 20;
	this->armorDamageReduction = 5;
	this->level = 1.0;
	std::cout << this->name << ": Hi ! I'm ready !" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
leaq 0x18(%rdi), %rbx
movb $0x0, 0x28(%rdi)
movaps 0xcde(%rip), %xmm0      # 0x2010
movups %xmm0, (%rdi)
movq %rbx, %rdi
callq 0x1090
movabsq $0x140000001e, %rax     # imm = 0x140000001E
movq %rax, 0x38(%r14)
movl $0x5, 0x40(%r14)
movl $0x3f800000, 0x10(%r14) # imm = 0x3F800000
movq 0x2c76(%rip), %rdi      # 0x3fd8
movq %rbx, %rsi
callq 0x10e0
leaq 0xcaf(%rip), %rsi       # 0x2020
movq %rax, %rdi
callq 0x1110
movq %rax, %rdi
callq 0x1080
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1070
movq %r14, %rdi
callq 0x1140
nop
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day03/ex01/FragTrap.cpp
// Function: FragTrap::takeDamage(unsigned int)
void		FragTrap::takeDamage(unsigned int damage)
{
	damage -= this->armorDamageReduction;
	damage = (damage < 0 ? 0 : damage);
	this->hitPoints -= damage;
	this->hitPoints = (this->hitPoints < 0 ? 0 : this->hitPoints);
	std::cout << this->name << " took " << damage << " damages.";
	std::cout << " He has now " << this->hitPoints << " hit points." << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
subl 0x40(%rdi), %r14d
movl (%rdi), %eax
subl %r14d, %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
movl %ecx, (%rdi)
leaq 0x18(%rdi), %rsi
movq 0x2a37(%rip), %r15      # 0x3fd8
movq %r15, %rdi
callq 0x10e0
leaq 0xad8(%rip), %rsi       # 0x2088
movq %rax, %rdi
callq 0x1110
movq %rax, %rdi
movq %r14, %rsi
callq 0x10a0
leaq 0xa9d(%rip), %rsi       # 0x2067
movq %rax, %rdi
callq 0x1110
leaq 0xab6(%rip), %rsi       # 0x208f
movq %r15, %rdi
callq 0x1110
movl (%rbx), %esi
movq %rax, %rdi
callq 0x1130
leaq 0xaaa(%rip), %rsi       # 0x209c
movq %rax, %rdi
callq 0x1110
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1080
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day03/ex01/FragTrap.cpp
// Function: FragTrap::vaulthunter_dot_exe(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void		FragTrap::vaulthunter_dot_exe(std::string const &target)
{
	int			choice;
	std::string	tool;

	if (this->energyPoints < 25)
	{
		std::cout << this->name << " tried to use vaulthunter_dot_exe but doesn't have enough energy !" << std::endl;
		return ;
	}
	this->energyPoints -= 25;
	this->energyPoints = (this->energyPoints < 0 ? 0 : this->energyPoints);
	choice = rand() % 5;
	switch (choice) {
		case 0:
			tool = "a shovel";
			break;
		case 1:
			tool = "a keyboard";
			break;
		case 2:
			tool = "a glass of beer";
			break;
		case 3:
			tool = "an avocado";
			break;
		case 4:
			tool = "a cup of coffee";
			break;
	}
	std::cout << this->name << " attacked " << target << " with " << tool << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %r14
movb $0x0, (%rax)
movl 0x8(%rdi), %eax
cmpl $0x18, %eax
jg 0x16b6
addq $0x18, %r14
movq 0x293b(%rip), %rdi      # 0x3fd8
movq %r14, %rsi
callq 0x10e0
leaq 0xa1a(%rip), %rsi       # 0x20c6
movq %rax, %rdi
callq 0x1110
jmp 0x1731
movq %rsi, %rbx
addl $-0x19, %eax
movl %eax, 0x8(%r14)
callq 0x1030
pushq $0x5
popq %rcx
cltd
idivl %ecx
cmpl $0x4, %edx
ja 0x16e9
movl %edx, %eax
leaq 0xa77(%rip), %rcx       # 0x2150
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
leaq -0x30(%rbp), %rdi
callq 0x1160
addq $0x18, %r14
movq 0x28e4(%rip), %rdi      # 0x3fd8
movq %r14, %rsi
callq 0x10e0
leaq 0x943(%rip), %rsi       # 0x2046
movq %rax, %rdi
callq 0x1110
movq %rax, %rdi
movq %rbx, %rsi
callq 0x10e0
leaq 0xa2b(%rip), %rsi       # 0x2148
movq %rax, %rdi
callq 0x1110
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x10e0
movq %rax, %rdi
callq 0x1080
leaq -0x30(%rbp), %rdi
callq 0x1070
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x1070
movq %rbx, %rdi
callq 0x1140
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day03/ex01/ScavTrap.cpp
// Function: ScavTrap::ScavTrap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ScavTrap::ScavTrap(std::string name)
{
	this->hitPoints = 100;
	this->maxHit = 100;
	this->energyPoints = 50;
	this->maxEnergyPoints = 50;
	this->name = name;
	this->meleeAttackDamage = 20;
	this->rangedAttackDamage = 15;
	this->armorDamageReduction = 3;
	this->level = 1.0;
	std::cout << this->name << ": Hey ! At your service." << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
leaq 0x18(%rdi), %rbx
movb $0x0, 0x28(%rdi)
movaps 0x9da(%rip), %xmm0      # 0x2170
movups %xmm0, (%rdi)
movq %rbx, %rdi
callq 0x1090
movabsq $0xf00000014, %rax      # imm = 0xF00000014
movq %rax, 0x38(%r14)
movl $0x3, 0x40(%r14)
movl $0x3f800000, 0x10(%r14) # imm = 0x3F800000
movq 0x2812(%rip), %rdi      # 0x3fd8
movq %rbx, %rsi
callq 0x10e0
leaq 0x9ab(%rip), %rsi       # 0x2180
movq %rax, %rdi
callq 0x1110
movq %rax, %rdi
callq 0x1080
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1070
movq %r14, %rdi
callq 0x1140
nop
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day03/ex01/ScavTrap.cpp
// Function: ScavTrap::challengeNewcomer()
void		ScavTrap::challengeNewcomer(void)
{
	int			choice;
	std::string	challenge;

	choice = rand() % 5;
	switch (choice) {
		case 0:
			challenge = "jump off the 20th floor";
			break;
		case 1:
			challenge = "do a backflip";
			break;
		case 2:
			challenge = "eat an spider";
			break;
		case 3:
			challenge = "walk 5 meters on your hands";
			break;
		case 4:
			challenge = "make me a coffee";
			break;
	}
	std::cout << this->name << ": I have a challenge for you: " << challenge << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq -0x18(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
callq 0x1030
pushq $0x5
popq %rcx
cltd
idivl %ecx
cmpl $0x5, %edx
jae 0x1b15
movl %edx, %eax
leaq 0x767(%rip), %rcx       # 0x226c
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
leaq -0x28(%rbp), %rdi
callq 0x1160
addq $0x18, %rbx
movq 0x24b8(%rip), %rdi      # 0x3fd8
movq %rbx, %rsi
callq 0x10e0
leaq 0x71d(%rip), %rsi       # 0x224c
movq %rax, %rdi
callq 0x1110
leaq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x10e0
movq %rax, %rdi
callq 0x1080
leaq -0x28(%rbp), %rdi
callq 0x1070
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x1070
movq %rbx, %rdi
callq 0x1140
nop
// File: /workspace/github_cpp_makefile_star2_O2/ammarfaizi2[P]TeaCurlCpp/TeaCurl.cpp
// Function: TeaCurl::setUp()
void TeaCurl::setUp() {
	curl_easy_setopt(this->ch, CURLOPT_URL, this->url.c_str());
	curl_easy_setopt(this->ch, CURLOPT_SSL_VERIFYPEER, 0);
	curl_easy_setopt(this->ch, CURLOPT_SSL_VERIFYHOST, 0);
	curl_easy_setopt(this->ch, CURLOPT_FOLLOWLOCATION, 1);
	
	curl_easy_setopt(this->ch, CURLOPT_WRITEFUNCTION, TeaCurl::__teaCurlWriteFunc);	
	curl_easy_setopt(this->ch, CURLOPT_WRITEDATA, &this->out);

	curl_easy_setopt(this->ch, CURLOPT_HEADERFUNCTION, TeaCurl::__teaCurlWriteFunc);
	curl_easy_setopt(this->ch, CURLOPT_WRITEHEADER, &this->responseHeader);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x40(%rbx), %rdx
movl $0x2712, %esi           # imm = 0x2712
xorl %eax, %eax
callq 0x2130
movq (%rbx), %rdi
pushq $0x40
popq %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2130
movq (%rbx), %rdi
pushq $0x51
popq %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2130
movq (%rbx), %rdi
pushq $0x34
popq %rsi
pushq $0x1
popq %rdx
xorl %eax, %eax
callq 0x2130
movq (%rbx), %rdi
leaq -0x145(%rip), %r14      # 0x2720
movl $0x4e2b, %esi           # imm = 0x4E2B
movq %r14, %rdx
xorl %eax, %eax
callq 0x2130
movq (%rbx), %rdi
leaq 0x20(%rbx), %rdx
movl $0x2711, %esi           # imm = 0x2711
xorl %eax, %eax
callq 0x2130
movq (%rbx), %rdi
movl $0x4e6f, %esi           # imm = 0x4E6F
movq %r14, %rdx
xorl %eax, %eax
callq 0x2130
movq (%rbx), %rdi
subq $-0x80, %rbx
movl $0x272d, %esi           # imm = 0x272D
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O2/ammarfaizi2[P]TeaCurlCpp/TeaCurl.cpp
// Function: TeaCurl::exec()
void TeaCurl::exec() {
	this->res = curl_easy_perform(ch);
	if(this->res == CURLE_OK) {
		curl_easy_getinfo(this->ch, CURLINFO_RESPONSE_CODE, &this->httpCode);
	} else {
		this->error = curl_easy_strerror(this->res);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2100
movl %eax, 0x8(%rbx)
testl %eax, %eax
je 0x28f2
movl %eax, %edi
callq 0x20d0
addq $0x60, %rbx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21f0
movq (%rbx), %rdi
addq $0x10, %rbx
movl $0x200002, %esi         # imm = 0x200002
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2160
// File: /workspace/github_cpp_makefile_star2_O2/0x0584[P]scmin-plus/src/sexpr/types.cpp
// Function: sexpr::sexpr_conslist::islist()
bool sexpr::sexpr_conslist::islist() {
    auto walk = cdr;
    while (walk->iscons())
        walk = walk->cdr();
    return walk->isnil();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rdi), %rsi
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
callq 0x3e44
leaq -0x30(%rbp), %r14
leaq -0x38(%rbp), %r15
movq -0x28(%rbp), %rdi
callq 0x49c4
testb %al, %al
je 0x3895
movq -0x28(%rbp), %rsi
movq %r15, %rdi
callq 0x5f48
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4354
movq %r14, %rdi
callq 0x3e82
jmp 0x3867
movq -0x28(%rbp), %rdi
callq 0x49a8
movl %eax, %ebx
leaq -0x20(%rbp), %rdi
callq 0x3e82
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x38ba
jmp 0x38ba
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/0x0584[P]scmin-plus/src/sexpr/types.cpp
// Function: sexpr::sexpr_lambda::require_evaled_args()
bool sexpr::sexpr_lambda::require_evaled_args() {
    return not (native == builtin::_quote
                or native == builtin::_quasiquote
                or native == builtin::_define
                or native == builtin::_set
                or native == builtin::_unset
                or native == builtin::_cons_car_flavor
                or native == builtin::_cons_cdr_flavor
                or native == builtin::_if
                or native == builtin::_cond
                or native == builtin::_let
                or native == builtin::_let_astrk
                or native == builtin::_let_rec
                or native == builtin::_do);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x58(%rdi), %rax
cmpq 0x1446b(%rip), %rax     # 0x17fd0
setne %cl
cmpq 0x14421(%rip), %rax     # 0x17f90
setne %dl
andb %cl, %dl
cmpq 0x143b5(%rip), %rax     # 0x17f30
setne %cl
cmpq 0x1441b(%rip), %rax     # 0x17fa0
setne %sil
andb %cl, %sil
andb %dl, %sil
cmpq 0x1442a(%rip), %rax     # 0x17fc0
setne %cl
cmpq 0x143d8(%rip), %rax     # 0x17f78
setne %dl
andb %cl, %dl
cmpq 0x14394(%rip), %rax     # 0x17f40
setne %cl
andb %dl, %cl
andb %sil, %cl
cmpq 0x143ed(%rip), %rax     # 0x17fa8
setne %dl
cmpq 0x14373(%rip), %rax     # 0x17f38
setne %sil
andb %dl, %sil
cmpq 0x14395(%rip), %rax     # 0x17f68
setne %dl
andb %sil, %dl
cmpq 0x143b8(%rip), %rax     # 0x17f98
setne %sil
andb %dl, %sil
andb %cl, %sil
cmpq 0x1437f(%rip), %rax     # 0x17f70
setne %cl
cmpq 0x143f5(%rip), %rax     # 0x17ff0
setne %al
andb %cl, %al
andb %sil, %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/0x0584[P]scmin-plus/src/sexpr/sexpr.cpp
// Function: sexpr::length()
size_t sexpr::length() {
    size_t sz = 1;
    sexpr_t walk;

    if (isatom() or ispair())
        return 0;
    walk = cdr();
    while (not walk->isnil())
        sz++, walk = walk->cdr();
    return sz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
callq 0x4a68
testb %al, %al
jne 0x4bae
movq %rbx, %rdi
callq 0x4a24
testb %al, %al
je 0x4bc9
xorl %ebx, %ebx
leaq -0x28(%rbp), %rdi
callq 0x3e82
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0x5f48
leaq -0x30(%rbp), %r14
leaq -0x40(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4354
leaq -0x38(%rbp), %rdi
callq 0x3e82
pushq $0x1
popq %rbx
leaq -0x38(%rbp), %r12
movq -0x30(%rbp), %rdi
callq 0x49a8
testb %al, %al
jne 0x4bb0
movq -0x30(%rbp), %rsi
movq %r15, %rdi
callq 0x5f48
incq %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x4354
movq %r12, %rdi
callq 0x3e82
jmp 0x4bf8
jmp 0x4c2d
jmp 0x4c2d
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/0x0584[P]scmin-plus/src/sexpr/cons.cpp
// Function: cons_append(std::shared_ptr<sexpr> const&, std::shared_ptr<sexpr>&, std::shared_ptr<sexpr>&)
bool cons_append(const sexpr_t& e, sexpr_t& expr, sexpr_t& tail) {
    if (e == nullptr)
        return false;
    if (not expr)
        tail = expr = cons(e, nil());
    else {
        tail->setcdr(cons(e, nil()));
        tail = tail->cdr();
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %r13
testq %r13, %r13
je 0x5ecc
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, (%rsi)
je 0x5e88
movq (%rbx), %r14
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x4d18
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4dd5
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x5f06
leaq -0x30(%rbp), %rdi
callq 0x3e82
leaq -0x40(%rbp), %rdi
callq 0x3e82
movq (%rbx), %rsi
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x5f48
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4354
leaq -0x30(%rbp), %rdi
jmp 0x5ec7
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0x4d18
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4dd5
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x4354
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6002
leaq -0x30(%rbp), %rdi
callq 0x3e82
leaq -0x40(%rbp), %rdi
callq 0x3e82
testq %r13, %r13
setne %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5ef1
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3e82
jmp 0x5ef4
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3e82
movq %rbx, %rdi
callq 0x3330
nop
// File: /workspace/github_cpp_makefile_star2_O2/0x0584[P]scmin-plus/src/sexpr/cons.cpp
// Function: sexpr::setcdr(std::shared_ptr<sexpr> const&)
bool sexpr::setcdr(const sexpr_t& e) {
    if (not (ispair() or islist()))
        return false;
    any_cast<sexpr_conslist *>(*blob)->cdr = e;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4a24
testb %al, %al
jne 0x5f28
movq %r14, %rdi
callq 0x49e0
testb %al, %al
je 0x5f40
movq (%r14), %rdi
callq 0x4c41
leaq 0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x6002
movb $0x1, %al
jmp 0x5f42
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/0x0584[P]scmin-plus/src/sexpr/cons.cpp
// Function: sexpr::setcar(std::shared_ptr<sexpr> const&)
bool sexpr::setcar(const sexpr_t& e) {
    if (not (ispair() or islist()))
        return false;
    any_cast<sexpr_conslist *>(*blob)->car = e;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4a24
testb %al, %al
jne 0x5fa8
movq %r14, %rdi
callq 0x49e0
testb %al, %al
je 0x5fbf
movq (%r14), %rdi
callq 0x4c41
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6002
movb $0x1, %al
jmp 0x5fc1
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq