LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/simap[P]ecctools/lib/uECC.c
// Function: uECC_make_key
int uECC_make_key(uint8_t *public_key,
                  uint8_t *private_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
    uECC_word_t tries;

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

        if (EccPoint_compute_public_key(_public, _private, curve)) {
#if uECC_VLI_NATIVE_LITTLE_ENDIAN == 0
            uECC_vli_nativeToBytes(private_key, BITS_TO_BYTES(curve->num_n_bits), _private);
            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;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rsi, (%rsp)
movq %rdi, 0x8(%rsp)
leaq 0x28(%rdx), %r12
movl $0x40, %r15d
leaq 0x10(%rsp), %r13
leaq 0x30(%rsp), %rbx
xorl %ebp, %ebp
movswl 0x2(%r14), %eax
leal 0x3f(%rax), %ecx
addl $0x7e, %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
shrl $0x6, %eax
movsbl %al, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x182b
testl %eax, %eax
je 0x181a
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x18f2
testq %rax, %rax
jne 0x1744
decq %r15
jne 0x16fe
jmp 0x181a
movswl 0x2(%r14), %ecx
leal 0x7(%rcx), %edx
leal 0xe(%rcx), %eax
testl %edx, %edx
cmovnsl %edx, %eax
testl %ecx, %ecx
movq 0x8(%rsp), %r10
movq (%rsp), %r8
jle 0x1790
sarl $0x3, %eax
xorl %ecx, %ecx
movb $0x1, %dl
leal -0x1(%rdx), %esi
notl %ecx
addl %eax, %ecx
movl %ecx, %edi
andl $-0x8, %edi
movq 0x10(%rsp,%rdi), %rdi
shll $0x3, %ecx
shrq %cl, %rdi
movsbq %sil, %rcx
movb %dil, (%r8,%rcx)
movsbl %dl, %ecx
incb %dl
cmpl %ecx, %eax
jg 0x1768
movsbl 0x1(%r14), %eax
movl $0x1, %ebp
testl %eax, %eax
jle 0x181a
movslq %eax, %rdx
leal -0x8(,%rax,8), %esi
decl %eax
xorl %edi, %edi
movl %eax, %ecx
andl $-0x8, %ecx
movq 0x30(%rsp,%rcx), %r8
movl %esi, %ecx
andb $0x38, %cl
shrq %cl, %r8
movb %r8b, (%r10,%rdi)
incq %rdi
addl $-0x8, %esi
decl %eax
cmpq %rdi, %rdx
jne 0x17ac
movsbq 0x1(%r14), %rcx
testq %rcx, %rcx
jle 0x181a
addq %rcx, %r10
movsbq (%r14), %rax
leaq (%rsp,%rax,8), %rax
addq $0x30, %rax
movslq %ecx, %rdx
leal -0x8(,%rdx,8), %esi
leal -0x1(%rdx), %edi
xorl %r8d, %r8d
movl %edi, %ecx
andl $-0x8, %ecx
movq (%rax,%rcx), %r9
movl %esi, %ecx
andb $0x38, %cl
shrq %cl, %r9
movb %r9b, (%r10,%r8)
incq %r8
addl $-0x8, %esi
decl %edi
cmpq %r8, %rdx
jne 0x17f8
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/simap[P]ecctools/lib/uECC.c
// Function: uECC_generate_random_int(unsigned long*, unsigned long const*, signed char)
uECC_VLI_API int uECC_generate_random_int(uECC_word_t *random,
                                          const uECC_word_t *top,
                                          wordcount_t num_words) {
    uECC_word_t mask = (uECC_word_t)-1;
    uECC_word_t tries;
    bitcount_t num_bits = uECC_vli_numBits(top, num_words);

    if (!g_rng_function) {
        return 0;
    }

    for (tries = 0; tries < uECC_RNG_MAX_TRIES; ++tries) {
        if (!g_rng_function((uint8_t *)random, num_words * uECC_WORD_SIZE)) {
            return 0;
	    }
        random[num_words - 1] &= mask >> ((bitcount_t)(num_words * uECC_WORD_SIZE * 8 - num_bits));
        if (!uECC_vli_isZero(random, num_words) &&
		        uECC_vli_cmp(top, random, num_words) == 1) {
            return 1;
        }
    }
    return 0;
}

// Assembly:
cmpq $0x0, 0x787d(%rip)      # 0x90b0
je 0x18e8
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movl %edx, 0x4(%rsp)
movsbl %dl, %ebx
movq %rsi, 0x10(%rsp)
movq %rsi, %rdi
movl %ebx, %esi
callq 0x3aad
movzbl %bl, %r13d
movl %r13d, %ecx
shll $0x6, %ecx
subl %eax, %ecx
movq $-0x1, %r14
shrq %cl, %r14
leal (,%rbx,8), %ebp
movq %rbx, 0x8(%rsp)
movsbq %bl, %r12
xorl %ebx, %ebx
movq %r15, %rdi
movl %ebp, %esi
callq *0x781d(%rip)           # 0x90b0
testl %eax, %eax
je 0x18d7
andq %r14, -0x8(%r15,%r12,8)
cmpb $0x0, 0x4(%rsp)
jle 0x18ce
xorl %ecx, %ecx
xorl %eax, %eax
orq (%r15,%rcx,8), %rax
incq %rcx
cmpq %rcx, %r13
jne 0x18a7
testq %rax, %rax
je 0x18ce
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rdx
callq 0x2399
cmpb $0x1, %al
je 0x18eb
incq %rbx
cmpq $0x40, %rbx
jne 0x1888
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
movl $0x1, %eax
jmp 0x18d9
// File: /workspace/github_cpp_makefile_star2_O3/simap[P]ecctools/lib/uECC.c
// Function: EccPoint_compute_public_key(unsigned long*, unsigned long*, uECC_Curve_t const*)
static uECC_word_t EccPoint_compute_public_key(uECC_word_t *result,
                                               uECC_word_t *private_key,
                                               uECC_Curve curve) {
    uECC_word_t tmp1[uECC_MAX_WORDS];
    uECC_word_t tmp2[uECC_MAX_WORDS];
    uECC_word_t *p2[2] = {tmp1, tmp2};
    uECC_word_t carry;

    /* Regularize the bitcount for the private key so that attackers cannot use a side channel
       attack to learn the number of leading zeros. */
    carry = regularize_k(private_key, tmp1, tmp2, curve);

    EccPoint_mult(result, curve->G, p2[!carry], 0, curve->num_n_bits + 1, curve);

    if (EccPoint_isZero(result, curve)) {
        return 0;
    }
    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x30(%rsp), %rsi
movq %rsi, (%rsp)
leaq 0x10(%rsp), %rdx
movq %rdx, 0x8(%rsp)
movq %rax, %rdi
movq %r14, %rcx
callq 0x1b68
leaq 0x48(%r14), %rsi
xorl $0x1, %eax
movq (%rsp,%rax,8), %rdx
movzwl 0x2(%r14), %eax
incl %eax
movswl %ax, %r8d
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %ecx, %ecx
movq %r14, %r9
callq 0x1c27
movb (%r14), %al
addb %al, %al
testb %al, %al
jle 0x1981
movzbl %al, %eax
pxor %xmm0, %xmm0
xorl %ecx, %ecx
movdqu (%rbx,%rcx,8), %xmm1
por %xmm1, %xmm0
addq $0x2, %rcx
cmpq %rcx, %rax
jne 0x195a
pxor %xmm1, %xmm1
pcmpeqd %xmm1, %xmm0
movmskps %xmm0, %eax
xorl %r15d, %r15d
xorl $0xf, %eax
setne %r15b
movq %r15, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/simap[P]ecctools/lib/uECC.c
// Function: uECC_vli_bytesToNative(unsigned long*, unsigned char const*, int)
uECC_VLI_API void uECC_vli_bytesToNative(uECC_word_t *native,
                                         const uint8_t *bytes,
                                         int num_bytes) {
    wordcount_t i;
    uECC_vli_clear(native, (num_bytes + (uECC_WORD_SIZE - 1)) / uECC_WORD_SIZE);
    for (i = 0; i < num_bytes; ++i) {
        unsigned b = num_bytes - 1 - i;
        native[b / uECC_WORD_SIZE] |=
            (uECC_word_t)bytes[i] << (8 * (b % uECC_WORD_SIZE));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leal 0x7(%rbx), %eax
leal 0xe(%rbx), %edx
testl %eax, %eax
cmovnsl %eax, %edx
sarl $0x3, %edx
testb %dl, %dl
jle 0x1b33
andl $0x7f, %edx
shll $0x3, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x1050
testl %ebx, %ebx
jle 0x1b62
xorl %edx, %edx
xorl %eax, %eax
notl %edx
addl %ebx, %edx
movsbq %al, %rax
movzbl (%r14,%rax), %esi
leal (,%rdx,8), %ecx
shlq %cl, %rsi
andl $-0x8, %edx
orq %rsi, (%r15,%rdx)
incb %al
movsbl %al, %edx
cmpl %ebx, %edx
jl 0x1b3b
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/simap[P]ecctools/lib/uECC.c
// Function: regularize_k(unsigned long const*, unsigned long*, unsigned long*, uECC_Curve_t const*)
static uECC_word_t regularize_k(const uECC_word_t * const k,
                                uECC_word_t *k0,
                                uECC_word_t *k1,
                                uECC_Curve curve) {
    wordcount_t num_n_words = BITS_TO_WORDS(curve->num_n_bits);
    bitcount_t num_n_bits = curve->num_n_bits;
    uECC_word_t carry = uECC_vli_add(k0, k, curve->n, num_n_words) ||
        (num_n_bits < ((bitcount_t)num_n_words * uECC_WORD_SIZE * 8) &&
         uECC_vli_testBit(k0, num_n_bits));
    uECC_vli_add(k1, k0, curve->n, num_n_words);
    return carry;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movswl 0x2(%rcx), %r9d
leal 0x3f(%r9), %eax
leal 0x7e(%r9), %r8d
testl %eax, %eax
cmovnsl %eax, %r8d
sarl $0x6, %r8d
testb %r8b, %r8b
jle 0x1bc9
movl %r8d, %eax
andl $0x7f, %eax
xorl %r10d, %r10d
xorl %r11d, %r11d
movq %r11, %rbx
movq (%rdi,%r10,8), %r14
leaq (%r14,%r11), %r15
addq 0x28(%rcx,%r10,8), %r15
xorl %r11d, %r11d
cmpq %r14, %r15
setb %r11b
cmoveq %rbx, %r11
movq %r15, (%rsi,%r10,8)
incq %r10
cmpq %r10, %rax
jne 0x1b95
movl $0x1, %eax
testq %r11, %r11
jne 0x1bee
movsbl %r8b, %eax
shll $0x6, %eax
cmpl %r9d, %eax
jle 0x1bec
movl %r9d, %eax
sarl $0x6, %eax
cltq
movq (%rsi,%rax,8), %rdi
xorl %eax, %eax
btq %r9, %rdi
setb %al
jmp 0x1bee
xorl %eax, %eax
testb %r8b, %r8b
jle 0x1c21
andl $0x7f, %r8d
xorl %edi, %edi
xorl %r9d, %r9d
movq (%rsi,%rdi,8), %r10
leaq (%r10,%r9), %r11
addq 0x28(%rcx,%rdi,8), %r11
xorl %ebx, %ebx
cmpq %r10, %r11
setb %bl
cmovneq %rbx, %r9
movq %r11, (%rdx,%rdi,8)
incq %rdi
cmpq %rdi, %r8
jne 0x1bfc
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/simap[P]ecctools/lib/uECC.c
// Function: uECC_compress
void uECC_compress(const uint8_t *public_key, uint8_t *compressed, uECC_Curve curve) {
    wordcount_t i;
    for (i = 0; i < curve->num_bytes; ++i) {
        compressed[i+1] = public_key[i];
    }
#if uECC_VLI_NATIVE_LITTLE_ENDIAN
    compressed[0] = 2 + (public_key[curve->num_bytes] & 0x01);
#else
    compressed[0] = 2 + (public_key[curve->num_bytes * 2 - 1] & 0x01);
#endif
}

// Assembly:
movb 0x1(%rdx), %al
testb %al, %al
jle 0x1fc8
xorl %ecx, %ecx
movb (%rdi,%rcx), %al
movb %al, 0x1(%rsi,%rcx)
incq %rcx
movsbq 0x1(%rdx), %rax
cmpq %rax, %rcx
jl 0x1fb4
movsbq %al, %rax
movb -0x1(%rdi,%rax,2), %al
andb $0x1, %al
orb $0x2, %al
movb %al, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/simap[P]ecctools/lib/uECC.c
// Function: uECC_decompress
void uECC_decompress(const uint8_t *compressed, uint8_t *public_key, uECC_Curve curve) {
#if uECC_VLI_NATIVE_LITTLE_ENDIAN
    uECC_word_t *point = (uECC_word_t *)public_key;
#else
    uECC_word_t point[uECC_MAX_WORDS * 2];
#endif
    uECC_word_t *y = point + curve->num_words;
#if uECC_VLI_NATIVE_LITTLE_ENDIAN
    bcopy(public_key, compressed+1, curve->num_bytes);
#else
    uECC_vli_bytesToNative(point, compressed + 1, curve->num_bytes);
#endif
    curve->x_side(y, point, curve);
    curve->mod_sqrt(y, curve);

    if ((y[0] & 0x01) != (compressed[0] & 0x01)) {
        uECC_vli_sub(y, curve->p, y, curve->num_words);
    }

#if uECC_VLI_NATIVE_LITTLE_ENDIAN == 0
    uECC_vli_nativeToBytes(public_key, curve->num_bytes, point);
    uECC_vli_nativeToBytes(public_key + curve->num_bytes, curve->num_bytes, y);
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movsbq (%rdx), %rax
leaq (%rsp,%rax,8), %r14
leaq 0x1(%rdi), %rsi
movsbl 0x1(%rdx), %edx
movq %rsp, %r13
movq %r13, %rdi
callq 0x1b04
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq *0xb8(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq *0xb0(%r15)
movl (%r14), %eax
andl $0x1, %eax
movzbl (%r12), %ecx
andl $0x1, %ecx
cmpl %ecx, %eax
je 0x206d
movsbq (%r15), %rax
testq %rax, %rax
jle 0x206d
xorl %ecx, %ecx
xorl %edx, %edx
movq 0x8(%r15,%rcx,8), %rsi
movq (%r14,%rcx,8), %rdi
addq %rdx, %rdi
xorl %r8d, %r8d
subq %rdi, %rsi
setb %r8b
testq %rdi, %rdi
cmovneq %r8, %rdx
movq %rsi, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x2044
movsbl 0x1(%r15), %eax
testl %eax, %eax
jle 0x20e3
movslq %eax, %rdx
leal -0x8(,%rax,8), %esi
decl %eax
xorl %edi, %edi
movl %eax, %ecx
andl $-0x8, %ecx
movq (%rsp,%rcx), %r8
movl %esi, %ecx
andb $0x38, %cl
shrq %cl, %r8
movb %r8b, (%rbx,%rdi)
incq %rdi
addl $-0x8, %esi
decl %eax
cmpq %rdi, %rdx
jne 0x2084
movsbq 0x1(%r15), %rax
testq %rax, %rax
jle 0x20e3
addq %rax, %rbx
cltq
leal -0x8(,%rax,8), %edx
leal -0x1(%rax), %esi
xorl %edi, %edi
movl %esi, %ecx
andl $-0x8, %ecx
movq (%r14,%rcx), %r8
movl %edx, %ecx
andb $0x38, %cl
shrq %cl, %r8
movb %r8b, (%rbx,%rdi)
incq %rdi
addl $-0x8, %edx
decl %esi
cmpq %rdi, %rax
jne 0x20c1
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/simap[P]ecctools/lib/uECC.c
// Function: uECC_valid_point(unsigned long const*, uECC_Curve_t const*)
int uECC_valid_point(const uECC_word_t *point, uECC_Curve curve) {
    uECC_word_t tmp1[uECC_MAX_WORDS];
    uECC_word_t tmp2[uECC_MAX_WORDS];
    wordcount_t num_words = curve->num_words;

    /* The point at infinity is invalid. */
    if (EccPoint_isZero(point, curve)) {
        return 0;
    }

    /* x and y must be smaller than p. */
    if (uECC_vli_cmp_unsafe(curve->p, point, num_words) != 1 ||
            uECC_vli_cmp_unsafe(curve->p, point + num_words, num_words) != 1) {
        return 0;
    }

    uECC_vli_modSquare_fast(tmp1, point + num_words, curve);
    curve->x_side(tmp2, point, curve); /* tmp2 = x^3 + ax + b */

    /* Make sure that y^2 == x^3 + ax + b */
    return (int)(uECC_vli_equal(tmp1, tmp2, num_words));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movzbl (%rsi), %r12d
leal (%r12,%r12), %eax
testb %al, %al
jle 0x2169
movq %rsi, %rbx
movq %rdi, %r14
movsbq %r12b, %rcx
movzbl %al, %eax
pxor %xmm0, %xmm0
xorl %edx, %edx
movdqu (%r14,%rdx,8), %xmm1
por %xmm1, %xmm0
addq $0x2, %rdx
cmpq %rdx, %rax
jne 0x211b
pxor %xmm1, %xmm1
pcmpeqd %xmm1, %xmm0
movmskps %xmm0, %edx
xorl %eax, %eax
xorl $0xf, %edx
je 0x216b
leaq -0x1(%r12), %rdx
testb %dl, %dl
js 0x216b
movl %edx, %edi
andl $0x7f, %edi
shll $0x3, %edi
movq 0x8(%rbx,%rdi), %rsi
movq (%r14,%rdi), %rdi
cmpq %rdi, %rsi
ja 0x2177
decq %rdx
cmpq %rdi, %rsi
jae 0x2145
jmp 0x216b
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq (%r14,%rcx,8), %rdx
leaq -0x1(%r12), %rcx
testb %cl, %cl
js 0x216b
movl %ecx, %edi
andl $0x7f, %edi
shll $0x3, %edi
movq 0x8(%rbx,%rdi), %rsi
movq (%rdx,%rdi), %rdi
cmpq %rdi, %rsi
ja 0x21a4
decq %rcx
cmpq %rdi, %rsi
jae 0x2180
jmp 0x216b
movsbl %r12b, %ecx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x561c
movq %rsp, %rdi
movq %r15, %rsi
callq *0xc0(%rbx)
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0xb8(%rbx)
decb %r12b
js 0x21ff
movzbl %r12b, %eax
xorl %ecx, %ecx
movq 0x20(%rsp,%rax,8), %rdx
xorq (%rsp,%rax,8), %rdx
orq %rdx, %rcx
addq $-0x1, %rax
jb 0x21e0
xorl %eax, %eax
testq %rcx, %rcx
sete %al
jmp 0x216b
movl $0x1, %eax
jmp 0x216b
// File: /workspace/github_cpp_makefile_star2_O3/simap[P]ecctools/lib/uECC.c
// Function: uECC_valid_public_key
int uECC_valid_public_key(const uint8_t *public_key, uECC_Curve curve) {
#if uECC_VLI_NATIVE_LITTLE_ENDIAN
    uECC_word_t *_public = (uECC_word_t *)public_key;
#else
    uECC_word_t _public[uECC_MAX_WORDS * 2];
#endif

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsbq 0x1(%rsi), %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x1b04
movsbq (%rbx), %rax
leaq (%rsp,%rax,8), %rdi
addq %r15, %r14
movq %r14, %rsi
movl %r15d, %edx
callq 0x1b04
movq %r12, %rdi
movq %rbx, %rsi
callq 0x20f1
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %rsi
movswl 0x2(%rdx), %r15d
leal 0x7(%r15), %eax
leal 0xe(%r15), %edx
testl %eax, %eax
cmovnsl %eax, %edx
sarl $0x3, %edx
movq %rsp, %rdi
callq 0x1b04
leal 0x3f(%r15), %eax
addl $0x7e, %r15d
testl %eax, %eax
cmovnsl %eax, %r15d
sarl $0x6, %r15d
testb %r15b, %r15b
jle 0x238a
movl %r15d, %eax
andl $0x7f, %eax
xorl %ecx, %ecx
xorl %edx, %edx
orq (%rsp,%rcx,8), %rdx
incq %rcx
cmpq %rcx, %rax
jne 0x22b2
xorl %ebp, %ebp
testq %rdx, %rdx
je 0x238c
leaq 0x28(%r14), %rdi
movsbl %r15b, %edx
movq %rsp, %rsi
callq 0x2399
cmpb $0x1, %al
jne 0x238c
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movq %r14, %rdx
callq 0x18f2
testq %rax, %rax
je 0x238c
movsbl 0x1(%r14), %eax
movl $0x1, %ebp
testl %eax, %eax
jle 0x238c
movslq %eax, %rdx
leal -0x8(,%rax,8), %esi
decl %eax
xorl %edi, %edi
movl %eax, %ecx
andl $-0x8, %ecx
movq 0x20(%rsp,%rcx), %r8
movl %esi, %ecx
andb $0x38, %cl
shrq %cl, %r8
movb %r8b, (%rbx,%rdi)
incq %rdi
addl $-0x8, %esi
decl %eax
cmpq %rdi, %rdx
jne 0x231a
movsbq 0x1(%r14), %rcx
testq %rcx, %rcx
jle 0x238c
addq %rcx, %rbx
movsbq (%r14), %rax
leaq (%rsp,%rax,8), %rax
addq $0x20, %rax
movslq %ecx, %rdx
leal -0x8(,%rdx,8), %esi
leal -0x1(%rdx), %edi
xorl %r8d, %r8d
movl %edi, %ecx
andl $-0x8, %ecx
movq (%rax,%rcx), %r9
movl %esi, %ecx
andb $0x38, %cl
shrq %cl, %r9
movb %r9b, (%rbx,%r8)
incq %r8
addl $-0x8, %esi
decl %edi
cmpq %r8, %rdx
jne 0x2366
jmp 0x238c
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/simap[P]ecctools/lib/uECC.c
// Function: uECC_vli_cmp(unsigned long const*, unsigned long const*, signed char)
uECC_VLI_API uECC_word_t uECC_vli_sub(uECC_word_t *result,
                                      const uECC_word_t *left,
                                      const uECC_word_t *right,
                                      wordcount_t num_words) {
    uECC_word_t borrow = 0;
    wordcount_t i;
    for (i = 0; i < num_words; ++i) {
        uECC_word_t diff = left[i] - right[i] - borrow;
        if (diff != left[i]) {
            borrow = (diff > left[i]);
        }
        result[i] = diff;
    }
    return borrow;
}

// Assembly:
testb %dl, %dl
jle 0x23ec
movzbl %dl, %eax
xorl %edx, %edx
xorl %ecx, %ecx
movq %rcx, %r8
movq (%rdi,%rdx,8), %r9
movq (%rsi,%rdx,8), %r10
addq %rcx, %r10
xorl %ecx, %ecx
subq %r10, %r9
setb %cl
testq %r10, %r10
cmoveq %r8, %rcx
movq %r9, -0x28(%rsp,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x23a4
xorl %edx, %edx
xorl %esi, %esi
orq -0x28(%rsp,%rdx,8), %rsi
incq %rdx
cmpq %rdx, %rax
jne 0x23d2
xorl %eax, %eax
testq %rsi, %rsi
setne %al
addl %ecx, %ecx
subl %ecx, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x182b
testl %eax, %eax
je 0x2472
movq %r12, %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
movq %r14, %rcx
movq 0x18(%rsp), %r8
movq %rbx, %r9
callq 0x2483
testl %eax, %eax
jne 0x246d
decq %r15
jne 0x2422
jmp 0x2472
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_O3/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 0x2a53
xorl %eax, %eax
movb (%rsi,%rax), %cl
xorb $0x36, %cl
movb %cl, (%r14,%rax)
incq %rax
movl 0x1c(%rbx), %ecx
cmpq %rcx, %rax
jb 0x2a3c
jmp 0x2a55
xorl %eax, %eax
cmpl 0x18(%rbx), %eax
jae 0x2a6c
movl %eax, %eax
movb $0x36, (%r14,%rax)
incq %rax
movl 0x18(%rbx), %ecx
cmpq %rcx, %rax
jb 0x2a5c
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_O3/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 0x2abb
xorl %eax, %eax
movb (%rsi,%rax), %cl
xorb $0x5c, %cl
movb %cl, (%r15,%rax)
incq %rax
movl 0x1c(%r14), %ecx
cmpq %rcx, %rax
jb 0x2aa3
jmp 0x2abd
xorl %eax, %eax
cmpl 0x18(%r14), %eax
jae 0x2ad6
movl %eax, %eax
movb $0x5c, (%r15,%rax)
incq %rax
movl 0x18(%r14), %ecx
cmpq %rcx, %rax
jb 0x2ac5
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_O3/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 0x347a
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 0x1b04
shll $0x3, %r15d
movswl 0x2(%rbx), %eax
subl %eax, %r15d
jbe 0x352b
cmpl $0x7f, %r13d
jb 0x34d7
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 0x34af
movzbl %bpl, %eax
leaq -0x1(%rax), %rcx
testb %cl, %cl
js 0x3501
movl %ecx, %esi
andl $0x7f, %esi
shll $0x3, %esi
movq 0x28(%rbx,%rsi), %rdx
movq (%r14,%rsi), %rsi
cmpq %rsi, %rdx
ja 0x352b
decq %rcx
cmpq %rsi, %rdx
jae 0x34df
testb %bpl, %bpl
jle 0x352b
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 0x350a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x561c
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 0x561c
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 0x561c
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 0x561c
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_O3/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 0x3ae0
movl %esi, %edx
andl $0x7f, %edx
decb %cl
decq %rsi
cmpq $0x0, (%rdi,%rdx,8)
je 0x3ac8
jmp 0x3ae2
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0x3b0c
movsbq %cl, %rdx
movq -0x8(%rdi,%rdx,8), %rdx
bsrq %rdx, %rsi
xorl $-0x40, %esi
addl $0x41, %esi
testq %rdx, %rdx
cmovel %eax, %esi
movsbl %cl, %eax
shll $0x6, %eax
addl %esi, %eax
addl $-0x40, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4186
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 0x4155
testq %r10, %r10
popq %rbx
popq %r14
jne 0x41ae
leaq -0x1(%rax), %rdx
testb %dl, %dl
js 0x41ae
movl %edx, %r9d
andl $0x7f, %r9d
shll $0x3, %r9d
movq (%rcx,%r9), %rsi
movq (%rdi,%r9), %r9
cmpq %r9, %rsi
ja 0x41d8
decq %rdx
cmpq %r9, %rsi
jae 0x418a
testb %r8b, %r8b
jle 0x41d8
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 0x41b7
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x55b3
testb %dl, %dl
jle 0x55b2
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 0x558e
retq
testb %dl, %dl
jle 0x55b2
movzbl %dl, %ecx
xorl %edx, %edx
xorl %eax, %eax
movq %rax, %r8
movq (%rdi,%rdx,8), %r9
leaq (%r9,%rax), %r10
addq (%rsi,%rdx,8), %r10
xorl %eax, %eax
cmpq %r9, %r10
setb %al
cmoveq %r8, %rax
movq %r10, (%rdi,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x55be
leaq (%rdi,%rcx,8), %rcx
xorl %esi, %esi
movq %rcx, %rdx
movq -0x8(%rdx), %r8
movq %r8, %r9
shrq %r9
orq %rsi, %r9
movq %r9, -0x8(%rdx)
leaq -0x8(%rdx), %r9
shlq $0x3f, %r8
movq %r9, %rdx
movq %r8, %rsi
cmpq %rdi, %r9
ja 0x55ee
testq %rax, %rax
je 0x55b2
orb $-0x80, -0x1(%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5684
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 0x5651
movq %r8, (%rdi,%r14,8)
incq %r14
incq %rbx
addq $0x8, %r15
cmpq %r11, %r14
jne 0x5642
jmp 0x568a
xorl %r9d, %r9d
xorl %r10d, %r10d
movsbl %cl, %eax
leal -0x1(,%rax,2), %r11d
cmpl %eax, %r11d
jle 0x5717
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 0x56f9
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 0x56d9
jmp 0x56fc
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 0x56a9
jmp 0x571a
movq %r9, %rax
movslq %r11d, %rcx
movq %rax, (%rdi,%rcx,8)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5844
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rdi), %r13
movb 0x70(%rdi), %al
movb $0x40, %cl
subb %al, %cl
movzbl %cl, %ecx
cmpq %rcx, %rbx
movl %ebx, %edx
cmovael %ecx, %edx
movzbl %al, %edi
addq %r13, %rdi
movzbl %dl, %r12d
movq %r14, %rsi
movq %r12, %rdx
callq 0x1070
movl %r12d, %eax
addb 0x70(%r15), %al
movb %al, 0x70(%r15)
cmpb $0x40, %al
jne 0x5830
movq %r15, %rdi
callq 0x5846
movb $0x0, 0x70(%r15)
xorl %eax, %eax
subq %r12, %rbx
addq %r12, %r14
testq %rbx, %rbx
jne 0x57ee
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5ae0
movl $0x37, %edx
subq %rax, %rdx
xorl %esi, %esi
callq 0x1050
jmp 0x5b14
movl $0x3f, %edx
subq %rax, %rdx
xorl %esi, %esi
callq 0x1050
movq %r12, %rdi
callq 0x5846
pxor %xmm0, %xmm0
movdqu %xmm0, 0x20(%r15)
movdqu %xmm0, 0x10(%r15)
movdqu %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 0x5846
movq $-0x8, %rax
pxor %xmm0, %xmm0
movdqu (%r15,%rax,4), %xmm1
movdqa %xmm1, %xmm2
punpckhbw %xmm0, %xmm2    # xmm2 = xmm2[8],xmm0[8],xmm2[9],xmm0[9],xmm2[10],xmm0[10],xmm2[11],xmm0[11],xmm2[12],xmm0[12],xmm2[13],xmm0[13],xmm2[14],xmm0[14],xmm2[15],xmm0[15]
pshuflw $0x1b, %xmm2, %xmm2     # xmm2 = xmm2[3,2,1,0,4,5,6,7]
pshufhw $0x1b, %xmm2, %xmm2     # xmm2 = xmm2[0,1,2,3,7,6,5,4]
punpcklbw %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1],xmm1[2],xmm0[2],xmm1[3],xmm0[3],xmm1[4],xmm0[4],xmm1[5],xmm0[5],xmm1[6],xmm0[6],xmm1[7],xmm0[7]
pshuflw $0x1b, %xmm1, %xmm1     # xmm1 = xmm1[3,2,1,0,4,5,6,7]
pshufhw $0x1b, %xmm1, %xmm1     # xmm1 = xmm1[0,1,2,3,7,6,5,4]
packuswb %xmm2, %xmm1
movdqu %xmm1, 0x20(%r15,%rax,4)
addq $0x4, %rax
jne 0x5b67
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
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rsp, %r12
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
jne 0x1847
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1110
movq (%r15), %rdi
movl 0x8(%rbx), %edx
movq (%rbx), %rax
movq -0x18(%rax), %rax
xorl %ecx, %ecx
testb $0x5, 0x20(%rbx,%rax)
setne %cl
movq %r12, %rsi
callq 0x11a0
testl %eax, %eax
jne 0x1719
movq (%r15), %rdi
callq 0x1120
movl %eax, %ebx
movq (%r15), %rdi
callq 0x1090
movq %rax, %r15
movq (%r14), %r14
testq %r14, %r14
je 0x1797
movq %r14, %rdi
callq 0x1080
movq 0x2866(%rip), %rdi      # 0x3ff0
movq %r14, %rsi
movq %rax, %rdx
callq 0x10f0
jmp 0x17b5
movq 0x2852(%rip), %rax      # 0x3ff0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x1160
movq 0x2834(%rip), %r14      # 0x3ff0
leaq 0x895(%rip), %rsi       # 0x2058
movl $0x1, %edx
movq %r14, %rdi
callq 0x10f0
movq %r14, %rdi
movl %r15d, %esi
callq 0x1170
movq %rax, %r14
leaq 0x875(%rip), %rsi       # 0x205a
movl $0x9, %edx
movq %rax, %rdi
callq 0x10f0
movl %ebx, %edi
callq 0x1030
testq %rax, %rax
je 0x1819
movq %rax, %rbx
movq %rax, %rdi
callq 0x1080
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x10f0
jmp 0x1833
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x1160
leaq 0x802(%rip), %rsi       # 0x203c
movl $0x1, %edx
movq %r14, %rdi
callq 0x10f0
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1932
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 -0x5d3(%rip), %rsi      # 0x12ec
leaq -0x1eb(%rip), %rdx      # 0x16db
callq 0x10c0
movq %rbx, %rdi
leaq -0x1d7(%rip), %rsi      # 0x16fe
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 0x190c
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x16ff
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10e0
movq %r13, %rdi
callq 0x1050
incq %r15
cmpl %r15d, %ebp
jne 0x1899
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 0x196c
jmp 0x1959
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x1050
jmp 0x195c
movq %rax, %r14
movq %rbx, %rdi
callq 0x10a0
movq %r14, %rdi
callq 0x1190
movq %rax, %rdi
callq 0x19da
// File: /workspace/github_cpp_makefile_star2_O3/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 0x39ad
movq 0x165e1(%rip), %rax     # 0x19f80
cmpb $0x0, (%rax)
je 0x39a9
incl 0x8(%rbx)
jmp 0x39ad
lock
incl 0x8(%rbx)
leaq -0x30(%rbp), %r15
movq %r14, %rdi
callq 0x4cb0
testb %al, %al
je 0x39f7
movq %r15, %rdi
movq %r14, %rsi
callq 0x61be
movq -0x30(%rbp), %r14
movq -0x28(%rbp), %r12
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
testq %rbx, %rbx
je 0x39f2
movq %rbx, %rdi
callq 0x4104
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x39f2
callq 0x4104
movq %r12, %rbx
jmp 0x39b1
movq %r14, %rdi
callq 0x4c74
movl %eax, %r14d
testq %rbx, %rbx
je 0x3a0f
movq %rbx, %rdi
callq 0x4104
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a23
jmp 0x3a23
movq %rax, %r14
testq %rbx, %rbx
je 0x3a33
movq %rbx, %rdi
callq 0x4104
movq %r14, %rdi
callq 0x3310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16161(%rip), %rax     # 0x19fd0
setne %cl
cmpq 0x16117(%rip), %rax     # 0x19f90
setne %dl
andb %cl, %dl
cmpq 0x160b3(%rip), %rax     # 0x19f38
setne %cl
cmpq 0x16111(%rip), %rax     # 0x19fa0
setne %sil
andb %cl, %sil
andb %dl, %sil
cmpq 0x16120(%rip), %rax     # 0x19fc0
setne %cl
cmpq 0x160ce(%rip), %rax     # 0x19f78
setne %dl
andb %cl, %dl
cmpq 0x16092(%rip), %rax     # 0x19f48
setne %cl
andb %dl, %cl
andb %sil, %cl
cmpq 0x160e3(%rip), %rax     # 0x19fa8
setne %dl
cmpq 0x16071(%rip), %rax     # 0x19f40
setne %sil
andb %dl, %sil
cmpq 0x1608b(%rip), %rax     # 0x19f68
setne %dl
andb %sil, %dl
cmpq 0x160ae(%rip), %rax     # 0x19f98
setne %sil
andb %dl, %sil
andb %cl, %sil
cmpq 0x16075(%rip), %rax     # 0x19f70
setne %cl
cmpq 0x160eb(%rip), %rax     # 0x19ff0
setne %al
andb %cl, %al
andb %sil, %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
callq 0x4dbc
testb %al, %al
jne 0x4fdf
movq %rbx, %rdi
callq 0x4d54
testb %al, %al
je 0x4ff3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x40(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x61be
movq (%r14), %r15
movq 0x8(%r14), %r14
movq %r15, %rdi
callq 0x4c74
movl $0x1, %ebx
testb %al, %al
jne 0x5065
leaq -0x40(%rbp), %r12
movq %r14, %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0x61be
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
testq %r13, %r13
je 0x5056
movq %r13, %rdi
callq 0x4104
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x5056
callq 0x4104
movq %r15, %rdi
callq 0x4c74
incq %rbx
testb %al, %al
je 0x501e
testq %r14, %r14
je 0x4fe1
movq %r14, %rdi
callq 0x4104
jmp 0x4fe1
movq %rax, %rbx
testq %r13, %r13
je 0x508b
movq %r13, %rdi
callq 0x4104
movq %rbx, %rdi
callq 0x3310