LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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:
movzbl %dl, %eax
testb %dl, %dl
jle 0x23cf
xorl %r8d, %r8d
xorl %ecx, %ecx
movq %rcx, %r9
movq (%rdi,%r8,8), %r10
movq (%rsi,%r8,8), %r11
addq %rcx, %r11
xorl %ecx, %ecx
subq %r11, %r10
setb %cl
testq %r11, %r11
cmoveq %r9, %rcx
movq %r10, -0x28(%rsp,%r8,8)
incq %r8
cmpq %r8, %rax
jne 0x23a0
addq %rcx, %rcx
jmp 0x23d1
xorl %ecx, %ecx
testb %dl, %dl
jle 0x23f0
xorl %edx, %edx
xorl %esi, %esi
orq -0x28(%rsp,%rdx,8), %rsi
incq %rdx
cmpq %rdx, %rax
jne 0x23d9
xorl %eax, %eax
testq %rsi, %rsi
setne %al
jmp 0x23f2
xorl %eax, %eax
subl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x40, %r15d
leaq 0x20(%rsp), %r14
xorl %ebp, %ebp
movswl 0x2(%rbx), %eax
leal 0x3f(%rax), %ecx
addl $0x7e, %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
shrl $0x6, %eax
movsbl %al, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x186e
testl %eax, %eax
je 0x2478
movq %r12, %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
movq %r14, %rcx
movq 0x18(%rsp), %r8
movq %rbx, %r9
callq 0x2489
testl %eax, %eax
jne 0x2473
decq %r15
jne 0x2428
jmp 0x2478
movl $0x1, %ebp
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_O1/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), %eax
leal (%rax,%rax), %r14d
addq 0x20(%rdi), %r14
testl %eax, %eax
je 0x2a6e
xorl %eax, %eax
movb (%rsi,%rax), %cl
xorb $0x36, %cl
movb %cl, (%r14,%rax)
incq %rax
movl 0x1c(%rbx), %ecx
cmpq %rcx, %rax
jb 0x2a57
jmp 0x2a70
xorl %eax, %eax
cmpl 0x18(%rbx), %eax
jae 0x2a87
movl %eax, %eax
movb $0x36, (%r14,%rax)
incq %rax
movl 0x18(%rbx), %ecx
cmpq %rcx, %rax
jb 0x2a77
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_O1/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), %eax
leal (%rax,%rax), %r15d
addq 0x20(%rdi), %r15
testl %eax, %eax
je 0x2ad6
xorl %eax, %eax
movb (%rsi,%rax), %cl
xorb $0x5c, %cl
movb %cl, (%r15,%rax)
incq %rax
movl 0x1c(%r14), %ecx
cmpq %rcx, %rax
jb 0x2abe
jmp 0x2ad8
xorl %eax, %eax
cmpl 0x18(%r14), %eax
jae 0x2af1
movl %eax, %eax
movb $0x5c, (%r15,%rax)
incq %rax
movl 0x18(%r14), %ecx
cmpq %rcx, %rax
jb 0x2ae0
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_O1/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
movq %rsi, %r12
movswl 0x2(%rcx), %r13d
leal 0x7(%r13), %eax
leal 0xe(%r13), %r15d
testl %eax, %eax
cmovnsl %eax, %r15d
movq %rdi, %r14
sarl $0x3, %r15d
leal 0x3f(%r13), %ebp
addl $0x7e, %r13d
testl %ebp, %ebp
cmovsl %r13d, %ebp
sarl $0x6, %ebp
cmpl %edx, %r15d
cmovael %edx, %r15d
testb %bpl, %bpl
jle 0x35af
movl %ebp, %edx
andl $0x7f, %edx
shll $0x3, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1050
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x1b19
shll $0x3, %r15d
movswl 0x2(%rbx), %eax
subl %eax, %r15d
jbe 0x366b
cmpl $0x7f, %r13d
jb 0x360c
movl %ebp, %eax
leaq (%r14,%rax,8), %rdx
movl $0x40, %eax
subl %r15d, %eax
xorl %esi, %esi
movq -0x8(%rdx), %rdi
movq %rdi, %r8
movl %r15d, %ecx
shrq %cl, %r8
orq %rsi, %r8
movq %r8, -0x8(%rdx)
movl %eax, %ecx
shlq %cl, %rdi
leaq -0x8(%rdx), %rcx
movq %rcx, %rdx
movq %rdi, %rsi
cmpq %r14, %rcx
ja 0x35e4
movzbl %bpl, %eax
leaq -0x1(%rax), %rcx
testb %cl, %cl
js 0x3636
movl %ecx, %esi
andl $0x7f, %esi
shll $0x3, %esi
movq 0x28(%rbx,%rsi), %rdx
movq (%r14,%rsi), %rsi
cmpq %rsi, %rdx
ja 0x363a
decq %rcx
cmpq %rsi, %rdx
jae 0x3614
xorl %ecx, %ecx
jmp 0x363c
movb $0x1, %cl
testb %bpl, %bpl
setle %dl
orb %cl, %dl
jne 0x366b
xorl %ecx, %ecx
xorl %edx, %edx
movq 0x28(%rbx,%rcx,8), %rsi
addq %rdx, %rsi
xorl %edi, %edi
subq %rsi, (%r14,%rcx,8)
setb %dil
testq %rsi, %rsi
cmovneq %rdi, %rdx
incq %rcx
cmpq %rcx, %rax
jne 0x364a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movzbl %r8b, %eax
testb %r8b, %r8b
jle 0x393a
pushq %r14
pushq %rbx
xorl %r9d, %r9d
xorl %r10d, %r10d
movq %r10, %r11
movq (%rsi,%r9,8), %rbx
movq (%rdx,%r9,8), %r14
addq %r10, %r14
xorl %r10d, %r10d
subq %r14, %rbx
setb %r10b
testq %r14, %r14
cmoveq %r11, %r10
movq %rbx, (%rdi,%r9,8)
incq %r9
cmpq %r9, %rax
jne 0x3904
testq %r10, %r10
sete %dl
popq %rbx
popq %r14
jmp 0x393c
movb $0x1, %dl
testb %r8b, %r8b
jle 0x396f
testb %dl, %dl
jne 0x396f
xorl %edx, %edx
xorl %esi, %esi
movq (%rdi,%rdx,8), %r8
leaq (%r8,%rsi), %r9
addq (%rcx,%rdx,8), %r9
xorl %r10d, %r10d
cmpq %r8, %r9
setb %r10b
cmovneq %r10, %rsi
movq %r9, (%rdi,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x3949
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
movsbl (%rcx), %ecx
movq %rsp, %rbp
movq %rbp, %rdi
movq %rdx, %rsi
callq 0x5802
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %rbp, %rsi
callq *0xc0(%rbx)
movsbl (%rbx), %ecx
movq %rsp, %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x5802
movq %r13, %rdi
movq %rbp, %rsi
callq *0xc0(%rbx)
movsbl (%rbx), %ecx
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5802
movq %r15, %rdi
movq %r13, %rsi
callq *0xc0(%rbx)
movsbl (%rbx), %ecx
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5802
movq %r14, %rdi
movq %r12, %rsi
callq *0xc0(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/simap[P]ecctools/lib/uECC.c
// Function: uECC_vli_numBits(unsigned long const*, signed char)
uECC_VLI_API bitcount_t uECC_vli_numBits(const uECC_word_t *vli, const wordcount_t max_words) {
    uECC_word_t i;
    uECC_word_t digit;

    wordcount_t num_digits = vli_numDigits(vli, max_words);
    if (num_digits == 0) {
        return 0;
    }

    digit = vli[num_digits - 1];
    for (i = 0; digit; ++i) {
        digit >>= 1;
    }

    return (((bitcount_t)(num_digits - 1) << uECC_WORD_BITS_SHIFT) + i);
}

// Assembly:
movl $0xff, %eax
leal -0x1(%rsi), %edx
leal 0x1(%rsi), %ecx
andl %eax, %esi
movzbl %dl, %edx
cmpb $-0x1, %dl
cmovll %edx, %eax
incb %al
decq %rsi
testb %sil, %sil
js 0x3c39
movl %esi, %edx
andl $0x7f, %edx
decb %cl
decq %rsi
cmpq $0x0, (%rdi,%rdx,8)
je 0x3c21
jmp 0x3c3b
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0x3c66
movsbl %cl, %edx
shll $0x6, %edx
movsbq %cl, %rcx
movq -0x8(%rdi,%rcx,8), %rcx
bsrq %rcx, %rsi
xorl $-0x40, %esi
addl $0x41, %esi
testq %rcx, %rcx
cmovel %eax, %esi
leal (%rdx,%rsi), %eax
addl $-0x40, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movzbl %r8b, %eax
testb %r8b, %r8b
jle 0x433c
pushq %r14
pushq %rbx
xorl %r9d, %r9d
xorl %r10d, %r10d
movq %r10, %r11
movq (%rsi,%r9,8), %rbx
leaq (%rbx,%r10), %r14
addq (%rdx,%r9,8), %r14
xorl %r10d, %r10d
cmpq %rbx, %r14
setb %r10b
cmoveq %r11, %r10
movq %r14, (%rdi,%r9,8)
incq %r9
cmpq %r9, %rax
jne 0x4304
testq %r10, %r10
popq %rbx
popq %r14
je 0x433c
testb %r8b, %r8b
jg 0x4376
jmp 0x439b
leaq -0x1(%rax), %rdx
testb %dl, %dl
js 0x4364
movl %edx, %r9d
andl $0x7f, %r9d
shll $0x3, %r9d
movq (%rcx,%r9), %rsi
movq (%rdi,%r9), %r9
cmpq %r9, %rsi
ja 0x4368
decq %rdx
cmpq %r9, %rsi
jae 0x4340
xorl %edx, %edx
jmp 0x436a
movb $0x1, %dl
testb %r8b, %r8b
setle %sil
orb %dl, %sil
jne 0x439b
xorl %edx, %edx
xorl %esi, %esi
movq (%rcx,%rdx,8), %r8
addq %rsi, %r8
xorl %r9d, %r9d
subq %r8, (%rdi,%rdx,8)
setb %r9b
testq %r8, %r8
cmovneq %r9, %rsi
incq %rdx
cmpq %rdx, %rax
jne 0x437a
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
testb $0x1, (%rdi)
jne 0x5786
testb %dl, %dl
jle 0x57f7
movzbl %dl, %eax
leaq (%rdi,%rax,8), %rax
xorl %ecx, %ecx
movq -0x8(%rax), %rdx
movq %rdx, %rsi
shrq %rsi
orq %rcx, %rsi
movq %rsi, -0x8(%rax)
leaq -0x8(%rax), %rsi
shlq $0x3f, %rdx
movq %rsi, %rax
movq %rdx, %rcx
cmpq %rdi, %rsi
ja 0x5760
jmp 0x57f7
movzbl %dl, %eax
testb %dl, %dl
jle 0x57c3
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r8, %r9
movq (%rdi,%rcx,8), %r10
leaq (%r10,%r8), %r11
addq (%rsi,%rcx,8), %r11
xorl %r8d, %r8d
cmpq %r10, %r11
setb %r8b
cmoveq %r9, %r8
movq %r11, (%rdi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x5792
testq %r8, %r8
sete %cl
jmp 0x57c5
movb $0x1, %cl
testb %dl, %dl
jle 0x57f3
leaq (%rdi,%rax,8), %rax
xorl %esi, %esi
movq -0x8(%rax), %r8
movq %r8, %r9
shrq %r9
orq %rsi, %r9
movq %r9, -0x8(%rax)
leaq -0x8(%rax), %r9
shlq $0x3f, %r8
movq %r9, %rax
movq %r8, %rsi
cmpq %rdi, %r9
ja 0x57cf
testb %cl, %cl
je 0x57f8
retq
movsbq %dl, %rax
orb $-0x80, -0x1(%rdi,%rax,8)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdx, %rbp
testb %cl, %cl
jle 0x586a
movzbl %cl, %r11d
movl $0x1, %ebx
xorl %r14d, %r14d
movq %rbp, %r15
xorl %r10d, %r10d
xorl %r9d, %r9d
movq %r9, %r8
movq %r10, %r9
movq %r15, %r12
xorl %r13d, %r13d
xorl %r10d, %r10d
movq (%r12), %rax
mulq (%rsi,%r13,8)
addq %rax, %r8
adcq %rdx, %r9
adcq $0x0, %r10
incq %r13
addq $-0x8, %r12
cmpq %r13, %rbx
jne 0x5837
movq %r8, (%rdi,%r14,8)
incq %r14
incq %rbx
addq $0x8, %r15
cmpq %r11, %r14
jne 0x5828
jmp 0x5870
xorl %r9d, %r9d
xorl %r10d, %r10d
movsbl %cl, %eax
leal -0x1(,%rax,2), %r11d
cmpl %eax, %r11d
jle 0x58fd
movq %rbp, -0x8(%rsp)
movsbq %cl, %rbx
movb $0x1, %bpl
movl %ecx, %r14d
movsbq %r14b, %r15
leal 0x1(%r15), %r14d
movl %r14d, %eax
subb %cl, %al
cmpb %cl, %al
jge 0x58df
leaq (,%r15,8), %r13
movsbq %bpl, %r8
leaq (,%r8,8), %rax
subq %rax, %r13
addq -0x8(%rsp), %r13
xorl %r12d, %r12d
movq (%r13), %rax
mulq (%rsi,%r8,8)
addq %rax, %r9
adcq %rdx, %r10
adcq $0x0, %r12
incq %r8
addq $-0x8, %r13
cmpq %rbx, %r8
jl 0x58bf
jmp 0x58e2
xorl %r12d, %r12d
movq %r10, %rax
movq %r9, (%rdi,%r15,8)
movsbl %r14b, %edx
incb %bpl
movq %r12, %r10
movq %rax, %r9
cmpl %edx, %r11d
jg 0x588f
jmp 0x5900
movq %r9, %rax
movslq %r11d, %rcx
movq %rax, (%rdi,%rcx,8)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
leaq (,%rdx,8), %rax
addq %rax, 0x68(%rdi)
testq %rdx, %rdx
je 0x5a34
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rdi), %r13
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 0x1070
movl %r12d, %eax
addb 0x70(%r15), %al
movb %al, 0x70(%r15)
cmpb $0x40, %al
jne 0x5a20
movq %r15, %rdi
callq 0x5a36
movb $0x0, 0x70(%r15)
subq %r12, %rbx
addq %r12, %r14
testq %rbx, %rbx
jne 0x59dd
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5ca4
movl $0x37, %edx
subq %rax, %rdx
xorl %esi, %esi
callq 0x1050
jmp 0x5cd4
movl $0x3f, %edx
subq %rax, %rdx
xorl %esi, %esi
callq 0x1050
movq %r12, %rdi
callq 0x5a36
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r15)
movups %xmm0, 0x10(%r15)
movups %xmm0, (%r15)
movq $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 0x5a36
movq $-0x8, %rax
movl (%r15,%rax,4), %ecx
bswapl %ecx
movl %ecx, 0x20(%r15,%rax,4)
incq %rax
jne 0x5d23
cmpq $0x20, %r14
movl $0x20, %edx
cmovbq %r14, %rdx
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1070
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp            # imm = 0x418
movq %rdx, 0x8(%rsp)
movq (%rsi), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsi,%rax)
jne 0x1878
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %rbx
movq 0x28b9(%rip), %r12      # 0x3ff0
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1110
movq (%r15), %rdi
movl 0x8(%r14), %edx
movq (%r14), %rax
movq -0x18(%rax), %rax
xorl %ecx, %ecx
testb $0x5, 0x20(%r14,%rax)
setne %cl
movq %rbx, %rsi
callq 0x11a0
testl %eax, %eax
jne 0x1865
movl %eax, %ebp
movq %r12, %rbx
movq (%r15), %rdi
callq 0x1120
movl %eax, 0x4(%rsp)
movq (%r15), %rdi
callq 0x1090
movq %rax, %r13
movq 0x8(%rsp), %rax
movq (%rax), %r12
testq %r12, %r12
je 0x17b4
movq %r12, %rdi
callq 0x1080
movq %rbx, %rdi
movq %r12, %rsi
movq %rbx, %r12
movq %rax, %rdx
callq 0x10f0
jmp 0x17ce
movq %rbx, %r12
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x1160
movl $0x1, %edx
movq %r12, %rdi
leaq 0x87e(%rip), %rsi       # 0x205b
callq 0x10f0
movq %r12, %rdi
movl %r13d, %esi
callq 0x1170
movq %rax, %r13
movl $0x9, %edx
movq %rax, %rdi
leaq 0x85e(%rip), %rsi       # 0x205d
callq 0x10f0
movl 0x4(%rsp), %edi
callq 0x1030
testq %rax, %rax
je 0x182d
movq %rax, %rbx
movq %rax, %rdi
callq 0x1080
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x10f0
jmp 0x1848
movq (%r13), %rax
movq -0x18(%rax), %rax
movq %r13, %rdi
addq %rax, %rdi
movl 0x20(%r13,%rax), %esi
orl $0x1, %esi
callq 0x1160
leaq 0x10(%rsp), %rbx
movl $0x1, %edx
movq %r13, %rdi
leaq 0x7e3(%rip), %rsi       # 0x203f
callq 0x10f0
testl %ebp, %ebp
je 0x1878
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%r14,%rax)
je 0x1737
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1966
movq %rsi, %r14
movl %edi, %ebp
xorl %edi, %edi
callq 0x1180
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq %rbx, (%rax)
movl %ebp, %ebp
movl $0x1, %r15d
leaq 0x8(%rsp), %r12
leaq 0x20(%rsp), %r13
movl $0x0, 0x10(%rsp)
movq (%r14,%r15,8), %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1040
movq %rbx, %rdi
leaq -0x607(%rip), %rsi      # 0x12ec
leaq -0x221(%rip), %rdx      # 0x16d9
callq 0x10c0
movq %rbx, %rdi
leaq -0x20d(%rip), %rsi      # 0x16fc
callq 0x1100
movq 0x8(%rsp), %rsi
movq %r13, %rdi
movl $0x8, %edx
callq 0x11b0
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
jne 0x1940
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x16fd
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10e0
movq %r13, %rdi
callq 0x1050
incq %r15
cmpl %r15d, %ebp
jne 0x18cd
movq %rbx, %rdi
callq 0x10a0
xorl %eax, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x19a0
jmp 0x198d
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1050
jmp 0x1990
movq %rax, %r14
movq %rbx, %rdi
callq 0x10a0
movq %r14, %rdi
callq 0x1190
movq %rax, %rdi
callq 0x1a0e
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
leaq 0x28(%rdi), %r15
movq %r15, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movaps 0x1cd8(%rip), %xmm0     # 0x3010
movups %xmm0, (%rdi)
movq %rbx, %rdi
callq 0x1070
movabsq $0x140000001e, %rax     # imm = 0x140000001E
movq %rax, 0x38(%r14)
movl $0x5, 0x40(%r14)
movl $0x3f800000, 0x10(%r14) # imm = 0x3F800000
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdx
movq 0x3c68(%rip), %rdi      # 0x4fd8
callq 0x1110
movq %rax, %r14
leaq 0x1ca1(%rip), %rsi      # 0x3020
movl $0x12, %edx
movq %rax, %rdi
callq 0x1110
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x10f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x13d4
movq (%r15), %rsi
incq %rsi
callq 0x1100
movq %r14, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day03/ex01/FragTrap.cpp
// Function: FragTrap::operator=(FragTrap const&)
FragTrap	&FragTrap::operator=(FragTrap const &other)
{
	this->hitPoints = other.hitPoints;
	this->maxHit = other.maxHit;
	this->energyPoints = other.energyPoints;
	this->maxEnergyPoints = other.maxEnergyPoints;
	this->name = other.name;
	this->meleeAttackDamage = other.meleeAttackDamage;
	this->rangedAttackDamage = other.rangedAttackDamage;
	this->armorDamageReduction = other.armorDamageReduction;
	this->level = other.level;
	return (*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %eax
movl %eax, (%rdi)
movl 0x4(%rsi), %eax
movl %eax, 0x4(%rdi)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movl 0xc(%rsi), %eax
movl %eax, 0xc(%rdi)
addq $0x18, %rsi
addq $0x18, %rdi
callq 0x1070
movl 0x38(%rbx), %eax
movl %eax, 0x38(%r14)
movl 0x3c(%rbx), %eax
movl %eax, 0x3c(%r14)
movl 0x40(%rbx), %eax
movl %eax, 0x40(%r14)
movss 0x10(%rbx), %xmm0
movss %xmm0, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movl %esi, %r15d
movq %rdi, %rbx
subl 0x40(%rdi), %r15d
movl (%rdi), %eax
subl %r15d, %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
movl %ecx, (%rdi)
movq 0x18(%rdi), %rsi
movq 0x20(%rdi), %rdx
movq 0x38e2(%rip), %r14      # 0x4fd8
movq %r14, %rdi
callq 0x1110
movq %rax, %r12
leaq 0x1980(%rip), %rsi      # 0x3088
movl $0x6, %edx
movq %rax, %rdi
callq 0x1110
movq %r12, %rdi
movq %r15, %rsi
callq 0x1080
leaq 0x1940(%rip), %rsi      # 0x3067
movl $0x9, %edx
movq %rax, %rdi
callq 0x1110
leaq 0x1954(%rip), %rsi      # 0x308f
movl $0xc, %edx
movq %r14, %rdi
callq 0x1110
movl (%rbx), %esi
movq %r14, %rdi
callq 0x1140
movq %rax, %rbx
leaq 0x1940(%rip), %rsi      # 0x309c
movl $0xc, %edx
movq %rax, %rdi
callq 0x1110
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movl 0x8(%rdi), %eax
cmpl $0x18, %eax
jg 0x18a4
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdx
movq 0x3769(%rip), %rdi      # 0x4fd8
callq 0x1110
movq %rax, %rbx
leaq 0x1848(%rip), %rsi      # 0x30c6
movl $0x42, %edx
movq %rax, %rdi
callq 0x1110
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10f0
jmp 0x1975
movq %rsi, %rbx
addl $-0x19, %eax
movl %eax, 0x8(%r14)
callq 0x1040
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
cmpl $0x4, %eax
ja 0x18fd
movl %eax, %eax
leaq 0x1874(%rip), %rdx      # 0x3150
movslq (%rdx,%rax,4), %rcx
addq %rdx, %rcx
leaq 0x187e(%rip), %rdx      # 0x3168
movq (%rdx,%rax,8), %r8
leaq -0x38(%rbp), %rdi
movq 0x8(%rdi), %rdx
xorl %esi, %esi
callq 0x1130
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdx
movq 0x36cc(%rip), %rdi      # 0x4fd8
callq 0x1110
movq %rax, %r14
leaq 0x172b(%rip), %rsi      # 0x3046
movl $0xa, %edx
movq %rax, %rdi
callq 0x1110
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x1110
movq %rax, %rbx
leaq 0x1807(%rip), %rsi      # 0x3148
movl $0x6, %edx
movq %rax, %rdi
callq 0x1110
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x1110
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x199d
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x1100
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x19c0
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x1100
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
leaq 0x28(%rdi), %r15
movq %r15, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movaps 0x178c(%rip), %xmm0     # 0x3190
movups %xmm0, (%rdi)
movq %rbx, %rdi
callq 0x1070
movabsq $0xf00000014, %rax      # imm = 0xF00000014
movq %rax, 0x38(%r14)
movl $0x3, 0x40(%r14)
movl $0x3f800000, 0x10(%r14) # imm = 0x3F800000
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdx
movq 0x359c(%rip), %rdi      # 0x4fd8
callq 0x1110
movq %rax, %r14
leaq 0x1755(%rip), %rsi      # 0x31a0
movl $0x18, %edx
movq %rax, %rdi
callq 0x1110
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x10f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1aa0
movq (%r15), %rsi
incq %rsi
callq 0x1100
movq %r14, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
callq 0x1040
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
cmpl $0x5, %eax
jae 0x1f71
movl %eax, %eax
leaq 0x1340(%rip), %rdx      # 0x3290
movslq (%rdx,%rax,4), %rcx
addq %rdx, %rcx
leaq 0x134a(%rip), %rdx      # 0x32a8
movq (%rdx,%rax,8), %r8
leaq -0x30(%rbp), %rdi
movq 0x8(%rdi), %rdx
xorl %esi, %esi
callq 0x1130
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
movq 0x3058(%rip), %rdi      # 0x4fd8
callq 0x1110
movq %rax, %rbx
leaq 0x12dd(%rip), %rsi      # 0x326c
movl $0x1e, %edx
movq %rax, %rdi
callq 0x1110
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq %rbx, %rdi
callq 0x1110
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x1feb
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x1100
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x200c
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x1100
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x40, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2130
movq (%rbx), %rdi
movl $0x51, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2130
movq (%rbx), %rdi
movl $0x34, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x2130
movq (%rbx), %rdi
leaq -0x17f(%rip), %r14      # 0x2840
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_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2110
movl %eax, 0x8(%rbx)
testl %eax, %eax
je 0x2a6b
movl %eax, %edi
callq 0x20e0
movq %rax, %r14
movq 0x68(%rbx), %r15
addq $0x60, %rbx
movq %rax, %rdi
callq 0x20c0
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
movq (%rbx), %rdi
addq $0x10, %rbx
movl $0x200002, %esi         # imm = 0x200002
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2160
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %rbx
testq %rbx, %rbx
je 0x39bd
movq 0x165d1(%rip), %rax     # 0x19f80
cmpb $0x0, (%rax)
je 0x39b9
incl 0x8(%rbx)
jmp 0x39bd
lock
incl 0x8(%rbx)
leaq -0x30(%rbp), %r15
movq %r14, %rdi
callq 0x4cb8
testb %al, %al
je 0x3a07
movq %r15, %rdi
movq %r14, %rsi
callq 0x627a
movq -0x30(%rbp), %r14
movq -0x28(%rbp), %r12
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
testq %rbx, %rbx
je 0x39f4
movq %rbx, %rdi
callq 0x4114
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x3a02
callq 0x4114
movq %r12, %rbx
jmp 0x39c1
movq %r14, %rdi
callq 0x4c7c
movl %eax, %r14d
testq %rbx, %rbx
je 0x3a1f
movq %rbx, %rdi
callq 0x4114
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a33
jmp 0x3a33
movq %rax, %r14
testq %rbx, %rbx
je 0x3a43
movq %rbx, %rdi
callq 0x4114
movq %r14, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x16151(%rip), %rax     # 0x19fd0
setne %cl
cmpq 0x16107(%rip), %rax     # 0x19f90
setne %dl
andb %cl, %dl
cmpq 0x160a3(%rip), %rax     # 0x19f38
setne %cl
cmpq 0x16101(%rip), %rax     # 0x19fa0
setne %sil
andb %cl, %sil
andb %dl, %sil
cmpq 0x16110(%rip), %rax     # 0x19fc0
setne %cl
cmpq 0x160be(%rip), %rax     # 0x19f78
setne %dl
andb %cl, %dl
cmpq 0x16082(%rip), %rax     # 0x19f48
setne %cl
andb %dl, %cl
andb %sil, %cl
cmpq 0x160d3(%rip), %rax     # 0x19fa8
setne %dl
cmpq 0x16061(%rip), %rax     # 0x19f40
setne %sil
andb %dl, %sil
cmpq 0x1607b(%rip), %rax     # 0x19f68
setne %dl
andb %sil, %dl
cmpq 0x1609e(%rip), %rax     # 0x19f98
setne %sil
andb %dl, %sil
andb %cl, %sil
cmpq 0x16065(%rip), %rax     # 0x19f70
setne %cl
cmpq 0x160db(%rip), %rax     # 0x19ff0
setne %al
andb %cl, %al
andb %sil, %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
callq 0x4dc4
xorl %r12d, %r12d
movl $0x0, %ebx
testb %al, %al
jne 0x50bf
movq %r14, %rdi
callq 0x4d5c
xorl %r12d, %r12d
movl $0x0, %ebx
testb %al, %al
jne 0x50bf
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x627a
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x505e
callq 0x4114
movq %r15, %rdi
callq 0x4c7c
movl $0x1, %ebx
testb %al, %al
je 0x5074
movq %r14, %r12
jmp 0x50bf
leaq -0x40(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x627a
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r12
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
testq %r14, %r14
je 0x509f
movq %r14, %rdi
callq 0x4114
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x50ad
callq 0x4114
movq %r15, %rdi
callq 0x4c7c
incq %rbx
movq %r12, %r14
testb %al, %al
je 0x5078
testq %r12, %r12
je 0x50cc
movq %r12, %rdi
callq 0x4114
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x50e0
movq %rax, %rbx
xorl %r14d, %r14d
jmp 0x50eb
movq %rax, %rbx
testq %r14, %r14
je 0x50f8
movq %r14, %rdi
callq 0x4114
movq %rbx, %rdi
callq 0x3310
// File: /workspace/github_cpp_makefile_star2_O1/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 0x61d4
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, (%rsi)
je 0x6167
movq (%rbx), %r14
leaq -0x50(%rbp), %r12
movq %r12, %rdi
callq 0x51b8
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x52f5
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x6218
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x6128
callq 0x4114
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x6136
callq 0x4114
movq (%rbx), %rsi
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x627a
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movq 0x8(%rbx), %rdi
movups %xmm0, (%rbx)
testq %rdi, %rdi
je 0x6161
callq 0x4114
movq -0x38(%rbp), %rdi
jmp 0x61ca
leaq -0x50(%rbp), %r12
movq %r12, %rdi
callq 0x51b8
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x52f5
movaps -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x40(%rbp)
movq 0x8(%r14), %rdi
movups %xmm0, (%r14)
leaq 0x8(%r14), %r15
testq %rdi, %rdi
je 0x61a3
callq 0x4114
movq (%r14), %rax
movq %rax, (%rbx)
addq $0x8, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x63b8
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x61c6
callq 0x4114
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x61d4
callq 0x4114
testq %r13, %r13
setne %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x61fe
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x6201
callq 0x4114
jmp 0x6201
movq %rax, %rbx
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x620f
callq 0x4114
movq %rbx, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4d5c
testb %al, %al
jne 0x623a
movq %r14, %rdi
callq 0x4cf4
testb %al, %al
je 0x6265
movq (%r14), %rdi
callq 0x5100
testq %rax, %rax
je 0x626c
movq (%rax), %rdi
movq (%rbx), %rax
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
addq $0x8, %rbx
movq %rbx, %rsi
callq 0x63b8
movb $0x1, %al
jmp 0x6267
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x4667
movq %rax, %rdi
callq 0x4085
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4d5c
testb %al, %al
jne 0x630c
movq %r14, %rdi
callq 0x4cf4
testb %al, %al
je 0x6336
movq (%r14), %rdi
callq 0x5100
testq %rax, %rax
je 0x633d
movq (%rax), %rdi
movq (%rbx), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
addq $0x8, %rbx
movq %rbx, %rsi
callq 0x63b8
movb $0x1, %al
jmp 0x6338
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x4667
movq %rax, %rdi
callq 0x4085