LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/scan.c
// Function: intcmp
static int intcmp(char const *dst, char const *src, int len)
{
    while (len >= (int)sizeof(int)) {
        if (*(int const*)src != *(int const*)dst) return 1;
        len -= sizeof(int), src += sizeof(int), dst +=sizeof(int);
    }

#   if __SIZEOF_INT__ == 8
    if (len >= 4) {
        if (*(int32_t const*)src != *(int32_t const*)dst) return 1;
        len -= 4, src += 4, dst += 4;
    }
#   endif

    if (len >= (int)sizeof(short)) {
        if (*(short const*)src != *(short const*)dst) return 1;
        len -= sizeof(short), src += sizeof(short), dst += sizeof(short);
    }

    return len && *src != *dst;
}

// Assembly:
xorl %ecx, %ecx
pushq $0x1
popq %rax
movl %edx, %r8d
cmpl $0x4, %r8d
jl 0x6b7d
movl (%rsi,%rcx), %r9d
cmpl (%rdi,%rcx), %r9d
jne 0x6bbd
addl $-0x4, %r8d
addq $0x4, %rcx
jmp 0x6b63
leaq (%rdi,%rcx), %r9
leaq (%rsi,%rcx), %r10
cmpl $0x2, %r8d
jl 0x6bad
movzwl (%r10), %r8d
cmpw (%r9), %r8w
jne 0x6bbd
subl %ecx, %edx
addl $-0x2, %edx
leaq (%rsi,%rcx), %r10
addq $0x2, %r10
leaq (%rdi,%rcx), %r9
addq $0x2, %r9
movl %edx, %r8d
testl %r8d, %r8d
je 0x6bbe
movb (%r10), %cl
xorl %eax, %eax
cmpb (%r9), %cl
setne %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/scan.c
// Function: scanstrx
char const *
scanstrx(char const *tgt, char const *pat)
{
    int patlen = strlen(pat);
    if (patlen == 0) return tgt;
    if (patlen == 1) return strchr(tgt, *pat);
    while ((tgt = scanstr2(tgt, pat)) && memcmp(tgt+2, pat+2, patlen-2)) ++tgt;
    return tgt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x30d0
testl %eax, %eax
je 0x6c2e
cmpl $0x1, %eax
jne 0x6bf7
movsbl (%r14), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x30c0
leaq 0x2(%r14), %r15
addl $-0x2, %eax
movslq %eax, %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6c3d
testq %rax, %rax
je 0x6c2c
movq %rax, %rbx
leaq 0x2(%rax), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x31d0
testl %eax, %eax
je 0x6c2e
incq %rbx
jmp 0x6c01
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/scan.c
// Function: scanstr2
char const*
scanstr2(char const *tgt, char const pat[2])
{
    XMM const zero = _mm_setzero_si128();
    XMM const p0   = xm_fill(pat[0]);
    XMM const p1   = xm_fill(pat[1]);
    uint16_t  pair = load16(pat);
    unsigned  f    = 15 & (uintptr_t)tgt;
    tgt -= f;
    while (1) {
        XMM x = xm_load(tgt);
        unsigned u = xm_same(x, zero) >> f;
        unsigned v = ~u & (u - 1) & ((xm_same(x, p0) & (xm_same(x, p1) >> 1)) >> f);
        if (v) return tgt + f + ffs(v) - 1;
        if (u) return NULL;
        tgt += 16;
        if (load16(tgt - 1) == pair) return tgt - 1;
        f = 0;
    }
}

// Assembly:
movq %rdi, %rax
movzbl (%rsi), %ecx
movd %ecx, %xmm0
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movzbl 0x1(%rsi), %ecx
movd %ecx, %xmm1
punpcklbw %xmm1, %xmm1    # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
movzwl (%rsi), %edx
movl %eax, %ecx
andl $0xf, %ecx
andq $-0x10, %rax
pxor %xmm2, %xmm2
movdqa (%rax), %xmm3
movdqa %xmm3, %xmm4
pcmpeqb %xmm2, %xmm4
pmovmskb %xmm4, %esi
shrl %cl, %esi
movl %esi, %edi
notl %edi
leal -0x1(%rsi), %r8d
andl %edi, %r8d
movdqa %xmm3, %xmm4
pcmpeqb %xmm0, %xmm4
pmovmskb %xmm4, %r9d
pcmpeqb %xmm1, %xmm3
pmovmskb %xmm3, %edi
shrl %edi
andl %r9d, %edi
shrl %cl, %edi
andl %r8d, %edi
jne 0x6cd3
testl %esi, %esi
jne 0x6cdf
leaq 0x10(%rax), %rsi
xorl %ecx, %ecx
cmpw %dx, 0xf(%rax)
movq %rsi, %rax
jne 0x6c7b
decq %rsi
movq %rsi, %rax
retq
movl %ecx, %ecx
bsfl %edi, %edx
addq %rcx, %rax
addq %rdx, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/scan.c
// Function: strchrs
char *strchrs(char *tgt, char const *pat)
{
    int     p0 = *pat++, rest = strlen(pat), hop = 1;
#if 0
    If the first char of pat occurs next at offset hop,
    then instead of memcmp, count the chars of pat+1 that match tgt,
    and (on failure) advance to min(hop, count+1).
    
    This just SCREAMS for REP CMPSB, which is faster than SCASB.
    Instead of memcmp, you need memprefix, an optimization of str
#endif

    hop = strcspn(pat, (char*)&p0);
    if (hop > 3) {
        for (; (tgt = strchr(tgt, p0)) && rest < memcmp(tgt+1, pat, rest); tgt += hop < rest ? hop : rest+1);
    } else {
        for (; (tgt = strchr(tgt, p0)) && memcmp(tgt+1, pat, rest); tgt++);
    }
//    for (; (tgt = strchr(tgt, p0)) && memcmp(tgt+1, pat, rest); tgt += hop);
    return tgt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movsbl (%rsi), %ebp
incq %rbx
leaq 0x4(%rsp), %r15
movl %ebp, (%r15)
movq %rbx, %rdi
callq 0x30d0
movq %rax, %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3060
movslq %r13d, %r15
cmpl $0x3, %eax
jle 0x6d59
movl %r13d, %ecx
incl %ecx
cmpl %r13d, %eax
cmovlq %rax, %rcx
movslq %ecx, %r12
movq %r14, %rdi
movl %ebp, %esi
callq 0x30c0
testq %rax, %rax
je 0x6d89
movq %rax, %r14
leaq 0x1(%rax), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x30e0
cmpl %r13d, %eax
jle 0x6d8e
addq %r12, %r14
jmp 0x6d2e
xorl %r12d, %r12d
movq %r14, %rdi
movl %ebp, %esi
callq 0x30c0
testq %rax, %rax
je 0x6d91
movq %rax, %r13
leaq 0x1(%rax), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x31d0
testl %eax, %eax
jne 0x6d5c
movq %r13, %r12
jmp 0x6d91
xorl %r12d, %r12d
jmp 0x6d91
movq %r14, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/tap.c
// Function: tap_init
void
tap_init(FILE * out)
{
    static int run_once = 0;

    if(!run_once) {
        tap_out  = out;
        test_pid = getpid();
        atexit(_cleanup);

        /* stdout needs to be unbuffered so that the output appears
           in the same place relative to stderr output as it does
           with Test::Harness */
        setbuf(tap_out, 0);
        run_once = 1;
    }

#ifndef _WIN32
    if (tap_flags & TAP_FLAG_DEBUG) {
        tap_saved_sig_handler[SIGINT]  = signal(SIGINT,  tap_debug_sig_handler);
        tap_saved_sig_handler[SIGTERM] = signal(SIGTERM, tap_debug_sig_handler);
    }
#endif
}

// Assembly:
pushq %rbx
cmpb $0x0, 0x545f(%rip)      # 0xc7dc
jne 0x73b2
movq %rdi, 0x542a(%rip)      # 0xc7b0
callq 0x32f0
movl %eax, 0x544f(%rip)      # 0xc7e0
leaq 0x50(%rip), %rdi        # 0x73e8
callq 0x79d0
movq 0x540c(%rip), %rdi      # 0xc7b0
xorl %esi, %esi
callq 0x32c0
movb $0x1, 0x542a(%rip)      # 0xc7dc
testb $0x2, 0x541f(%rip)      # 0xc7d8
je 0x73e6
leaq 0x13e(%rip), %rbx       # 0x7500
pushq $0x2
popq %rdi
movq %rbx, %rsi
callq 0x3240
movq %rax, 0x542c(%rip)      # 0xc800
pushq $0xf
popq %rdi
movq %rbx, %rsi
callq 0x3240
movq %rax, 0x5482(%rip)      # 0xc868
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/tap.c
// Function: tap_debug_sig_handler
static void
tap_debug_sig_handler(int sig)
{
    diag("tap_debug_sig_hander(sig=%d):", sig);

    if (tap_saved_sig_handler[sig] == SIG_DFL) {
        diag("    default handling: exiting with an error");
        exit(1);
    }

    if (tap_saved_sig_handler[sig] == SIG_IGN) {
        diag("    signal ignored");
    }
    else {
        diag("    forwarding signal to function at %p", tap_saved_sig_handler[sig]);
        (*tap_saved_sig_handler)(sig);
    }
}

// Assembly:
pushq %rbx
movl %edi, %ebx
leaq 0x18cb(%rip), %rdi      # 0x8dd5
movl %ebx, %esi
xorl %eax, %eax
callq 0x76bc
movslq %ebx, %rax
leaq 0x52d3(%rip), %rcx      # 0xc7f0
movq (%rcx,%rax,8), %rsi
cmpq $0x1, %rsi
je 0x7543
testq %rsi, %rsi
je 0x7552
leaq 0x18ff(%rip), %rdi      # 0x8e32
xorl %eax, %eax
callq 0x76bc
movl %ebx, %edi
popq %rbx
jmpq *0x52ad(%rip)           # 0xc7f0
leaq 0x18d5(%rip), %rdi      # 0x8e1f
xorl %eax, %eax
popq %rbx
jmp 0x76bc
leaq 0x189a(%rip), %rdi      # 0x8df3
xorl %eax, %eax
callq 0x76bc
pushq $0x1
popq %rdi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/tap.c
// Function: plan_no_plan
void
plan_no_plan(void)
{

    LOCK;

    tap_init(stdout);

    if(have_plan != 0) {
        fprintf(stderr, "You tried to plan twice!\n");
        test_died = 1;
        UNLOCK;
        exit(255);
    }

    have_plan = 1;
    no_plan = 1;

    UNLOCK;
}

// Assembly:
pushq %rax
movq 0x4a50(%rip), %rax      # 0xbfc0
movq (%rax), %rdi
callq 0x7375
cmpb $0x1, 0x5479(%rip)      # 0xc9f8
je 0x7591
movb $0x1, %al
movb %al, 0x546f(%rip)       # 0xc9f8
movb %al, 0x5471(%rip)       # 0xca00
popq %rax
retq
movq 0x4a40(%rip), %rax      # 0xbfd8
movq (%rax), %rcx
leaq 0x162b(%rip), %rdi      # 0x8bcd
pushq $0x19
popq %rsi
pushq $0x1
popq %rdx
callq 0x33c0
movb $0x1, 0x5448(%rip)      # 0xc9fc
movl $0xff, %edi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/tap.c
// Function: plan_skip_all
void
plan_skip_all(const char * reason)
{
    LOCK;

    tap_init(stdout);
    skip_all = 1;

    fprintf(tap_out, "1..0");

    if(reason != NULL) {
        fprintf(tap_out, " # Skip %s", reason);
    }

    fprintf(tap_out, "\n");
    UNLOCK;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x49f7(%rip), %rax      # 0xbfc0
movq (%rax), %rdi
callq 0x7375
movb $0x1, 0x542c(%rip)      # 0xca04
movq 0x51d1(%rip), %rcx      # 0xc7b0
leaq 0x1601(%rip), %rdi      # 0x8be7
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
callq 0x33c0
testq %rbx, %rbx
je 0x760e
movq 0x51b3(%rip), %rdi      # 0xc7b0
leaq 0x15e8(%rip), %rsi      # 0x8bec
movq %rbx, %rdx
xorl %eax, %eax
callq 0x32d0
movq 0x519b(%rip), %rsi      # 0xc7b0
pushq $0xa
popq %rdi
popq %rbx
jmp 0x3270
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/tap.c
// Function: tap_plan
void
tap_plan(unsigned tests, unsigned flags, FILE * output)
{
    LOCK;

    tap_flags = flags;
    tap_init(output != NULL ? output : stdout);

    if (have_plan != 0) {
        fprintf(stderr, "You tried to plan twice!\n");
        test_died = 1;
        UNLOCK;
        exit(255);
    }

    if (tests == 0) {
        fprintf(stderr, "You said to run 0 tests!  You've got to run something.\n");
        test_died = 1;
        UNLOCK;
        exit(255);
    }

    have_plan = 1;
    _expected_tests(tests);

    UNLOCK;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl %esi, 0x51b1(%rip)      # 0xc7d8
testq %rdx, %rdx
jne 0x7636
movq 0x498d(%rip), %rax      # 0xbfc0
movq (%rax), %rdx
movq %rdx, %rdi
callq 0x7375
cmpb $0x1, 0x53b3(%rip)      # 0xc9f8
je 0x7671
testl %ebx, %ebx
je 0x7686
movb $0x1, 0x53a6(%rip)      # 0xc9f8
movq 0x5157(%rip), %rdi      # 0xc7b0
leaq 0x16bb(%rip), %rsi      # 0x8d1b
movl %ebx, %edx
xorl %eax, %eax
callq 0x32d0
movl %ebx, 0x5399(%rip)      # 0xca08
popq %rbx
retq
movq 0x4960(%rip), %rax      # 0xbfd8
movq (%rax), %rcx
leaq 0x154b(%rip), %rdi      # 0x8bcd
pushq $0x19
jmp 0x7699
movq 0x494b(%rip), %rax      # 0xbfd8
movq (%rax), %rcx
leaq 0x1560(%rip), %rdi      # 0x8bf7
pushq $0x37
popq %rsi
pushq $0x1
popq %rdx
callq 0x33c0
movb $0x1, 0x5353(%rip)      # 0xc9fc
movl $0xff, %edi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/tap.c
// Function: diagv
static int
diagv(const char *fmt, va_list ap)
{
    int len;

    tap_init(stdout);
    fputs("# ", tap_out);
    len = vfprintf(tap_out, fmt, ap);
    fputs("\n", tap_out);

    return len + 3;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x486b(%rip), %rax      # 0xbfc0
movq (%rax), %rdi
callq 0x7375
movq 0x504c(%rip), %rsi      # 0xc7b0
leaq 0x16ef(%rip), %rdi      # 0x8e5a
callq 0x3220
movq 0x5039(%rip), %rdi      # 0xc7b0
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3290
movl %eax, %ebx
movq 0x5025(%rip), %rsi      # 0xc7b0
leaq 0x1453(%rip), %rdi      # 0x8be5
callq 0x3220
addl $0x3, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/tap.c
// Function: skip
void
skip(unsigned int n, const char *fmt, ...)
{
    va_list ap;
    char *  skip_msg;

    LOCK;

    va_start(ap, fmt);

    if (my_vasprintf(&skip_msg, fmt, ap) < 0)
        skip_msg = NULL;

    va_end(ap);

    while(n-- > 0) {
        test_count++;
        fprintf(tap_out, "ok %d # skip %s\n", test_count,
               skip_msg != NULL ?
               skip_msg : "libtap():malloc() failed");
    }

    free(skip_msg);
    UNLOCK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %edi, %ebx
leaq 0x30(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x7807
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %rdi, 0x10(%rdx)
leaq 0x8(%rsp), %rdi
callq 0x7291
testl %eax, %eax
js 0x783e
movq 0x8(%rsp), %r14
jmp 0x7841
xorl %r14d, %r14d
testq %r14, %r14
leaq 0x13f5(%rip), %r15      # 0x8c40
cmovneq %r14, %r15
leaq 0x13d9(%rip), %r12      # 0x8c2f
subl $0x1, %ebx
jb 0x787f
movl 0x4f57(%rip), %edx      # 0xc7b8
incl %edx
movl %edx, 0x4f4f(%rip)      # 0xc7b8
movq 0x4f40(%rip), %rdi      # 0xc7b0
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x32d0
jmp 0x7856
movq %r14, %rdi
callq 0x3250
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/tap.c
// Function: todo_start
void
todo_start(const char *fmt, ...)
{
    va_list ap;

    LOCK;

    va_start(ap, fmt);

    if (my_vasprintf(&todo_msg, fmt, ap) < 0)
        todo_msg = NULL;

    va_end(ap);
    todo = 1;

    UNLOCK;
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x78f4
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
leaq 0x4eb5(%rip), %rdi      # 0xc7d0
movq %r10, %rsi
callq 0x7291
testl %eax, %eax
jns 0x792f
andq $0x0, 0x4ea1(%rip)      # 0xc7d0
movb $0x1, 0x4e92(%rip)      # 0xc7c8
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yanniss[P]souffle-num-addon/./num256.cpp
// Function: number_to_hex
const char* number_to_hex(int32_t x) {
    thread_local static char out[STRING_LEN] = {"0x"};
    uint256_t result(x);
    string str_result = result.str(32, std::ios_base::hex);
    transform(str_result.begin(), str_result.end(), str_result.begin(), ::tolower);
    strcpy(out+2, str_result.c_str());
    return out;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movslq %edi, %rsi
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x45890
leaq -0x38(%rbp), %r14
pushq $0x20
popq %rdx
pushq $0x8
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x555f6
movq (%r14), %rbx
movq 0x8(%r14), %r14
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x248ec
movsbl (%rbx,%r15), %edi
callq 0xf800
movb %al, (%rbx,%r15)
incq %r15
jmp 0x248d4
movq %fs:0x0, %rax
leaq -0x690(%rax), %rbx
leaq -0x68e(%rax), %rdi
leaq -0x38(%rbp), %r14
movq (%r14), %rsi
callq 0xf510
movq %r14, %rdi
callq 0xfb08
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yanniss[P]souffle-num-addon/./num256.cpp
// Function: add_set
const char* add_set(const char *x, const char *y) {
    string y_str(y);
    set<string> strs = from_chars(x);
    if (strs.find(y_str) != strs.end()) return x;
    strs.insert(y_str);
    string joinedString = boost::algorithm::join(strs, "|");
    char* out = new char[joinedString.length() + 1];
    strcpy(out, joinedString.c_str());
    return out;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x2d680
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0x24998
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x57208
leaq -0x38(%rbp), %rcx
cmpq %rcx, %rax
jne 0x24b1c
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x54216
leaq 0x38189(%rip), %rdx     # 0x5cc72
leaq -0x80(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x33bfd
movq -0x78(%rbp), %rdi
incq %rdi
callq 0xf030
movq %rax, %rbx
leaq -0x80(%rbp), %r14
movq (%r14), %rsi
movq %rax, %rdi
callq 0xf510
movq %r14, %rdi
callq 0xfb08
leaq -0x40(%rbp), %rdi
callq 0x3aad6
leaq -0x60(%rbp), %rdi
callq 0xfb08
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0xfb08
jmp 0x24b4f
jmp 0x24b4c
jmp 0x24b4c
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3aad6
jmp 0x24b5d
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xfb08
movq %rbx, %rdi
callq 0xf9a0
// File: /workspace/github_cpp_makefile_star2_O2/yanniss[P]souffle-num-addon/./num256.cpp
// Function: add_256
const char* add_256(const char *x, const char *y) {
    thread_local static char out[STRING_LEN] = {"0x"}; 
    uint256_t my_x(x);
    uint256_t my_y(y);
    uint256_t result = my_x + my_y;
    string str_result = result.str(32, std::ios_base::hex);
    transform(str_result.begin(), str_result.end(), str_result.begin(), ::tolower);
    strcpy(out+2, str_result.c_str());
    return out;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
leaq -0x30(%rbp), %rax
movq %rdi, (%rax)
leaq -0x28(%rbp), %rbx
movq %rsi, (%rbx)
xorl %r12d, %r12d
leaq -0xe0(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x33b06
leaq -0xb0(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x33b06
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x33cbd
leaq -0x50(%rbp), %r14
pushq $0x20
popq %rdx
pushq $0x8
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x555f6
movq (%r14), %rbx
movq 0x8(%r14), %r14
cmpq %r12, %r14
je 0x24bff
movsbl (%rbx,%r12), %edi
callq 0xf800
movb %al, (%rbx,%r12)
incq %r12
jmp 0x24be7
movq %fs:0x0, %rax
leaq -0x640(%rax), %rbx
leaq -0x63e(%rax), %rdi
leaq -0x50(%rbp), %r14
movq (%r14), %rsi
callq 0xf510
movq %r14, %rdi
callq 0xfb08
movq %rbx, %rax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yanniss[P]souffle-num-addon/./num256.cpp
// Function: sub_256
const char* sub_256(const char *x, const char *y) {
    thread_local static char out[STRING_LEN] = {"0x"}; 
    uint256_t my_x(x);
    uint256_t my_y(y);
    uint256_t result = my_x - my_y;
    string str_result = result.str(32, ios_base::hex);
    transform(str_result.begin(), str_result.end(), str_result.begin(), ::tolower);
    strcpy(out+2, str_result.c_str());
    return out;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
leaq -0x30(%rbp), %rax
movq %rdi, (%rax)
leaq -0x28(%rbp), %rbx
movq %rsi, (%rbx)
xorl %r12d, %r12d
leaq -0xe0(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x33b06
leaq -0xb0(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x33b06
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x33ce7
leaq -0x50(%rbp), %r14
pushq $0x20
popq %rdx
pushq $0x8
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x555f6
movq (%r14), %rbx
movq 0x8(%r14), %r14
cmpq %r12, %r14
je 0x24cce
movsbl (%rbx,%r12), %edi
callq 0xf800
movb %al, (%rbx,%r12)
incq %r12
jmp 0x24cb6
movq %fs:0x0, %rax
leaq -0x5f0(%rax), %rbx
leaq -0x5ee(%rax), %rdi
leaq -0x50(%rbp), %r14
movq (%r14), %rsi
callq 0xf510
movq %r14, %rdi
callq 0xfb08
movq %rbx, %rax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yanniss[P]souffle-num-addon/./num256.cpp
// Function: eq_256
const char* eq_256(const char *x, const char *y) {
    thread_local static char out[STRING_LEN] = {"0x"}; 
    uint256_t my_x(x);
    uint256_t my_y(y);
    uint256_t result = my_x == my_y;
    string str_result = result.str(32, ios_base::hex);
    transform(str_result.begin(), str_result.end(), str_result.begin(), ::tolower);
    strcpy(out+2, str_result.c_str());
    return out;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
leaq -0x30(%rbp), %rax
movq %rdi, (%rax)
leaq -0x28(%rbp), %rbx
movq %rsi, (%rbx)
xorl %r12d, %r12d
leaq -0xe0(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x33b06
leaq -0xb0(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x33b06
movq %r14, %rdi
movq %r15, %rsi
callq 0x487ba
movzbl %al, %eax
xorps %xmm0, %xmm0
leaq -0x80(%rbp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %rax, (%rsi)
movq $0x1, 0x20(%rsi)
leaq -0x50(%rbp), %rbx
pushq $0x20
popq %rdx
pushq $0x8
popq %rcx
movq %rbx, %rdi
callq 0x555f6
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
cmpq %r12, %rbx
je 0x2536a
movsbl (%r14,%r12), %edi
callq 0xf800
movb %al, (%r14,%r12)
incq %r12
jmp 0x25352
movq %fs:0x0, %rax
leaq -0x370(%rax), %rbx
leaq -0x36e(%rax), %rdi
leaq -0x50(%rbp), %r14
movq (%r14), %rsi
callq 0xf510
movq %r14, %rdi
callq 0xfb08
movq %rbx, %rax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yanniss[P]souffle-num-addon/./num256.cpp
// Function: exp_256
const char* exp_256(const char *x, const char *y) {
    thread_local static char out[STRING_LEN] = {"0x"}; 
    uint256_t my_x(x);
    uint256_t my_y(y);
    uint256_t result = powm(my_x, my_y, numeric_limits<uint256_t>::max());
    string str_result = result.str(32, ios_base::hex);
    transform(str_result.begin(), str_result.end(), str_result.begin(), ::tolower);
    strcpy(out+2, str_result.c_str());
    return out;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
leaq -0x30(%rbp), %rax
movq %rdi, (%rax)
leaq -0x28(%rbp), %rbx
movq %rsi, (%rbx)
xorl %r12d, %r12d
leaq -0xf0(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x33b06
leaq -0xc0(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x33b06
pxor %xmm0, %xmm0
leaq -0x60(%rbp), %rcx
movdqa %xmm0, 0x20(%rcx)
pcmpeqd %xmm0, %xmm0
movdqa %xmm0, (%rcx)
movdqa %xmm0, 0x10(%rcx)
movq $0x4, 0x20(%rcx)
leaq -0x90(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x33e0d
leaq -0x60(%rbp), %r14
pushq $0x20
popq %rdx
pushq $0x8
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x555f6
movq (%r14), %rbx
movq 0x8(%r14), %r14
cmpq %r12, %r14
je 0x2553f
movsbl (%rbx,%r12), %edi
callq 0xf800
movb %al, (%rbx,%r12)
incq %r12
jmp 0x25527
movq %fs:0x0, %rax
leaq -0x2d0(%rax), %rbx
leaq -0x2ce(%rax), %rdi
leaq -0x60(%rbp), %r14
movq (%r14), %rsi
callq 0xf510
movq %r14, %rdi
callq 0xfb08
movq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yanniss[P]souffle-num-addon/./num256.cpp
// Function: smod_256
const char* smod_256(const char *x, const char *y) {
    thread_local static char out[STRING_LEN] = {"0x"}; 
    int256_t my_x(x);
    int256_t my_y(y);
    int256_t result = my_x % my_y;
    uint256_t unsigned_result(result);
    string str_result = unsigned_result.str(32, ios_base::hex);
    transform(str_result.begin(), str_result.end(), str_result.begin(), ::tolower);
    strcpy(out+2, str_result.c_str());
    return out;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
leaq -0x30(%rbp), %rax
movq %rdi, (%rax)
leaq -0x28(%rbp), %rbx
movq %rsi, (%rbx)
xorl %r12d, %r12d
leaq -0x110(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x33e48
leaq -0xe0(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x33e48
leaq -0xb0(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x33e69
leaq -0x80(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x4b778
leaq -0x50(%rbp), %rbx
pushq $0x20
popq %rdx
pushq $0x8
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x555f6
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
cmpq %r12, %rbx
je 0x25622
movsbl (%r14,%r12), %edi
callq 0xf800
movb %al, (%r14,%r12)
incq %r12
jmp 0x2560a
movq %fs:0x0, %rax
leaq -0x280(%rax), %rbx
leaq -0x27e(%rax), %rdi
leaq -0x50(%rbp), %r14
movq (%r14), %rsi
callq 0xf510
movq %r14, %rdi
callq 0xfb08
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yanniss[P]souffle-num-addon/./num256.cpp
// Function: shl_256
const char* shl_256(const char *x, const char *y) {
    thread_local static char out[STRING_LEN] = {"0x"}; 
    uint256_t my_x(y);
    long my_y = strtol(x, NULL, 16);
    uint256_t result = my_x << my_y;
    string str_result = result.str(32, ios_base::hex);
    transform(str_result.begin(), str_result.end(), str_result.begin(), ::tolower);
    strcpy(out+2, str_result.c_str());
    return out;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq -0x28(%rbp), %rax
movq %rsi, (%rax)
xorl %r15d, %r15d
leaq -0xb0(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x33b06
pushq $0x10
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf7a0
leaq -0x20(%rbp), %rdx
movq %rax, (%rdx)
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33ec1
leaq -0x48(%rbp), %r14
pushq $0x20
popq %rdx
pushq $0x8
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x555f6
movq (%r14), %rbx
movq 0x8(%r14), %r14
cmpq %r15, %r14
je 0x259b9
movsbl (%rbx,%r15), %edi
callq 0xf800
movb %al, (%rbx,%r15)
incq %r15
jmp 0x259a1
movq %fs:0x0, %rax
leaq -0x140(%rax), %rbx
leaq -0x13e(%rax), %rdi
leaq -0x48(%rbp), %r14
movq (%r14), %rsi
callq 0xf510
movq %r14, %rdi
callq 0xfb08
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yanniss[P]souffle-num-addon/./num256.cpp
// Function: sar_256
const char* sar_256(const char *x, const char *y) {
    thread_local static char out[STRING_LEN] = {"0x"};
    int256_t my_x(y);
    int256_t minus_zero = ((int256_t) 1) << 255;
    int256_t sign_bit = my_x & minus_zero;
    long my_y = strtol(x, NULL, 16);
    int256_t result;
    if (my_y >= 256) {
      if (sign_bit) result = -1;
      else result = 0;
    } else {  // there must be a better way to implement SAR w/ Boost, but who cares?
      for (result = my_x; my_y > 0; my_y--) {
        result = (result >> 1) | sign_bit;
      }
    }
    uint256_t unsigned_result(result);
    string str_result = unsigned_result.str(32, ios_base::hex);
    transform(str_result.begin(), str_result.end(), str_result.begin(), ::tolower);
    strcpy(out+2, str_result.c_str());
    return out;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rdi, %rbx
leaq -0x68(%rbp), %rax
movq %rsi, (%rax)
xorl %r15d, %r15d
leaq -0x130(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x33e48
xorps %xmm0, %xmm0
leaq -0xd0(%rbp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq $0x1, (%rsi)
movw $0x1, %r13w
movw %r13w, 0x20(%rsi)
movb %r15b, 0x22(%rsi)
leaq -0x60(%rbp), %r15
movl $0xff, (%r15)
leaq -0x160(%rbp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x33f6b
leaq -0xd0(%rbp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x33fc6
pushq $0x10
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf7a0
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movw %r13w, 0x20(%r15)
xorl %eax, %eax
movb %al, 0x22(%r15)
cmpq $0x100, %rbx            # imm = 0x100
jl 0x25c30
cmpw $0x1, -0xb0(%rbp)
setne %al
cmpq $0x0, -0xd0(%rbp)
setne %cl
orb %al, %cl
movzbl %cl, %esi
negq %rsi
leaq -0x60(%rbp), %rdi
callq 0x4c456
xorl %r15d, %r15d
leaq -0xa0(%rbp), %rbx
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4b778
leaq -0x100(%rbp), %r14
pushq $0x20
popq %rdx
pushq $0x8
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x555f6
movq (%r14), %rbx
movq 0x8(%r14), %r14
cmpq %r15, %r14
je 0x25bed
movsbl (%rbx,%r15), %edi
callq 0xf800
movb %al, (%rbx,%r15)
incq %r15
jmp 0x25bd5
movq %fs:0x0, %rax
leaq -0xa0(%rax), %rbx
leaq -0x9e(%rax), %rdi
leaq -0x100(%rbp), %r14
movq (%r14), %rsi
callq 0xf510
movq %r14, %rdi
callq 0xfb08
movq %rbx, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzwl 0x20(%r14), %edx
movw %dx, 0x20(%r15)
shll $0x3, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0xf480
movb 0x22(%r14), %al
movb %al, 0x22(%r15)
leaq -0x100(%rbp), %r15
leaq -0x2c(%rbp), %r12
leaq -0xa0(%rbp), %r13
leaq -0xd0(%rbp), %r14
testq %rbx, %rbx
jle 0x25b9e
movl $0x1, -0x2c(%rbp)
movq %r15, %rdi
leaq -0x60(%rbp), %rsi
movq %r12, %rdx
callq 0x3401e
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x33ff2
movl -0x81(%rbp), %eax
movl %eax, -0x41(%rbp)
movaps -0xa0(%rbp), %xmm0
movaps -0x90(%rbp), %xmm1
movaps %xmm1, -0x50(%rbp)
movaps %xmm0, -0x60(%rbp)
decq %rbx
jmp 0x25c69
// File: /workspace/github_cpp_makefile_star2_O2/yanniss[P]souffle-num-addon/./num256.cpp
// Function: not_256
const char* not_256(const char *x) {
    thread_local static char out[STRING_LEN] = {"0x"};
    uint256_t my_x(x);
    uint256_t result = ~my_x;
    string str_result = result.str(32, ios_base::hex);
    transform(str_result.begin(), str_result.end(), str_result.begin(), ::tolower);
    strcpy(out+2, str_result.c_str());
    return out;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
leaq -0x20(%rbp), %rsi
movq %rdi, (%rsi)
xorl %r15d, %r15d
leaq -0xa0(%rbp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33b06
leaq -0x70(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x34079
leaq -0x40(%rbp), %rbx
pushq $0x20
popq %rdx
pushq $0x8
popq %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x555f6
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
cmpq %r15, %rbx
je 0x25d28
movsbl (%r14,%r15), %edi
callq 0xf800
movb %al, (%r14,%r15)
incq %r15
jmp 0x25d10
movq %fs:0x0, %rax
leaq -0x50(%rax), %rbx
leaq -0x4e(%rax), %rdi
leaq -0x40(%rbp), %r14
movq (%r14), %rsi
callq 0xf510
movq %r14, %rdi
callq 0xfb08
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: uECC_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
pushq $0x41
popq %rbx
leaq 0x10(%rsp), %r13
leaq 0x30(%rsp), %rbp
xorl %r15d, %r15d
decq %rbx
je 0x1764
movswl 0x2(%r14), %eax
addl $0x3f, %eax
cltd
pushq $0x40
popq %rcx
idivl %ecx
movsbl %al, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x1776
testl %eax, %eax
je 0x1764
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x181a
testq %rax, %rax
je 0x16d3
movswl 0x2(%r14), %eax
addl $0x7, %eax
pushq $0x8
popq %rcx
cltd
idivl %ecx
leaq 0x10(%rsp), %rdx
movq (%rsp), %rdi
movl %eax, %esi
callq 0x1887
movsbl 0x1(%r14), %esi
leaq 0x30(%rsp), %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1887
movsbq 0x1(%r14), %rsi
addq %rsi, %rbx
movsbq (%r14), %rax
leaq (%rsp,%rax,8), %rdx
addq $0x30, %rdx
movq %rbx, %rdi
callq 0x1887
pushq $0x1
popq %r15
movl %r15d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: 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:
xorl %eax, %eax
cmpq $0x0, 0x6940(%rip)      # 0x80c0
je 0x1819
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movsbl %dl, %r12d
movq %rsi, (%rsp)
movq %rsi, %rdi
movl %r12d, %esi
callq 0x3223
movzbl %r12b, %ecx
shll $0x6, %ecx
subl %eax, %ecx
pushq $-0x1
popq %r13
shrq %cl, %r13
leal (,%r12,8), %ebp
movsbq %r12b, %rbx
pushq $0x40
popq %r14
subq $0x1, %r14
jb 0x1809
movq %r15, %rdi
movl %ebp, %esi
callq *0x68e8(%rip)           # 0x80c0
testl %eax, %eax
je 0x1809
andq %r13, -0x8(%r15,%rbx,8)
movq %r15, %rdi
movl %r12d, %esi
callq 0x1d5d
testq %rax, %rax
jne 0x17c7
movq (%rsp), %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x2096
cmpb $0x1, %al
jne 0x17c7
pushq $0x1
popq %rax
jmp 0x180b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: 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 %r14
pushq %rbx
subq $0x58, %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 0x1a25
leaq 0x48(%r14), %rsi
xorl $0x1, %eax
movq (%rsp,%rax,8), %rdx
movzwl 0x2(%r14), %eax
incl %eax
movswl %ax, %r8d
movq %rbx, %rdi
xorl %ecx, %ecx
movq %r14, %r9
callq 0x1ab8
movb (%r14), %al
addb %al, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1d5d
xorq $0x1, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: uECC_vli_nativeToBytes(unsigned char*, int, unsigned long const*)
uECC_VLI_API void uECC_vli_nativeToBytes(uint8_t *bytes,
                                         int num_bytes,
                                         const uECC_word_t *native) {
    wordcount_t i;
    for (i = 0; i < num_bytes; ++i) {
        unsigned b = num_bytes - 1 - i;
        bytes[i] = native[b / uECC_WORD_SIZE] >> (8 * (b % uECC_WORD_SIZE));
    }
}

// Assembly:
xorl %eax, %eax
movsbl %al, %eax
cmpl %esi, %eax
jge 0x18b2
movl %eax, %ecx
notl %ecx
addl %esi, %ecx
movl %ecx, %r8d
andl $-0x8, %r8d
movq (%rdx,%r8), %r8
shll $0x3, %ecx
shrq %cl, %r8
movslq %eax, %rcx
movb %r8b, (%rdi,%rcx)
incb %al
jmp 0x1889
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x8
popq %rcx
cltd
idivl %ecx
movsbl %al, %esi
callq 0x3272
xorl %eax, %eax
movsbl %al, %eax
cmpl %ebx, %eax
jge 0x1a1f
movl %eax, %edx
notl %edx
addl %ebx, %edx
movslq %eax, %rcx
movzbl (%r14,%rcx), %esi
leal (,%rdx,8), %ecx
shlq %cl, %rsi
andl $-0x8, %edx
orq %rsi, (%r15,%rdx)
incb %al
jmp 0x19f5
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rsi
movswl 0x2(%rcx), %r13d
leal 0x3f(%r13), %eax
pushq $0x40
popq %rcx
cltd
idivl %ecx
movl %eax, %r12d
addq $0x28, %rbx
movsbl %r12b, %ebp
movq %r14, %rdi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x3763
testq %rax, %rax
je 0x1a6e
pushq $0x1
popq %r12
jmp 0x1a96
movsbl %r12b, %eax
shll $0x6, %eax
cmpl %r13d, %eax
jle 0x1a93
movl %r13d, %eax
sarl $0x6, %eax
cltq
movq (%r14,%rax,8), %rax
xorl %r12d, %r12d
btq %r13, %rax
setb %r12b
jmp 0x1a96
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x3763
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: uECC_vli_isZero(unsigned long const*, signed char)
uECC_VLI_API uECC_word_t uECC_vli_isZero(const uECC_word_t *vli, wordcount_t num_words) {
    uECC_word_t bits = 0;
    wordcount_t i;
    for (i = 0; i < num_words; ++i) {
        bits |= vli[i];
    }
    return (bits == 0);
}

// Assembly:
xorl %eax, %eax
testb %sil, %sil
cmovlel %eax, %esi
movslq %esi, %rcx
xorl %edx, %edx
cmpq %rax, %rcx
je 0x1d78
orq (%rdi,%rax,8), %rdx
incq %rax
jmp 0x1d6a
xorl %eax, %eax
testq %rdx, %rdx
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
movsbq 0x1(%rdx), %rcx
cmpq %rcx, %rax
jge 0x1d99
movb (%rdi,%rax), %cl
movb %cl, 0x1(%rsi,%rax)
incq %rax
jmp 0x1d83
movb -0x1(%rdi,%rcx,2), %al
andb $0x1, %al
orb $0x2, %al
movb %al, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19d5
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 0x1e17
leaq 0x8(%r15), %rsi
movsbl (%r15), %ecx
movq %r14, %rdi
movq %r14, %rdx
callq 0x1e48
movsbl 0x1(%r15), %esi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x1887
movsbq 0x1(%r15), %rsi
addq %rsi, %rbx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1887
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: uECC_vli_sub(unsigned long*, 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:
xorl %r8d, %r8d
testb %cl, %cl
cmovlel %r8d, %ecx
movslq %ecx, %rcx
xorl %eax, %eax
cmpq %r8, %rcx
je 0x1e80
movq (%rsi,%r8,8), %r9
movq (%rdx,%r8,8), %r10
addq %rax, %r10
xorl %r11d, %r11d
subq %r10, %r9
setb %r11b
testq %r10, %r10
cmovneq %r11, %rax
movq %r9, (%rdi,%r8,8)
incq %r8
jmp 0x1e56
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
movsbq (%rsi), %rbx
leal (%rbx,%rbx), %eax
movsbl %al, %esi
callq 0x1d5d
xorl %r12d, %r12d
testq %rax, %rax
jne 0x1f0c
leaq 0x8(%r14), %rbp
movq %rbp, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0x1f1e
cmpb $0x1, %al
jne 0x1f0c
leaq (%r15,%rbx,8), %r13
movq %rbp, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x1f1e
cmpb $0x1, %al
jne 0x1f0c
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x1f4e
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0xb8(%r14)
movq %r12, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x1f59
movq %rax, %r12
movl %r12d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/simap[P]ecctools/lib/uECC.c
// Function: uECC_vli_equal(unsigned long const*, unsigned long const*, signed char)
uECC_VLI_API uECC_word_t uECC_vli_equal(const uECC_word_t *left,
                                        const uECC_word_t *right,
                                        wordcount_t num_words) {
    uECC_word_t diff = 0;
    wordcount_t i;
    for (i = num_words - 1; i >= 0; --i) {
        diff |= (left[i] ^ right[i]);
    }
    return (diff == 0);
}

// Assembly:
movzbl %dl, %eax
decq %rax
xorl %ecx, %ecx
testb %al, %al
js 0x1f7d
movl %eax, %edx
andl $0x7f, %edx
shll $0x3, %edx
movq (%rsi,%rdx), %r8
xorq (%rdi,%rdx), %r8
orq %r8, %rcx
decq %rax
jmp 0x1f61
xorl %eax, %eax
testq %rcx, %rcx
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19d5
movsbq (%rbx), %rax
leaq (%rsp,%rax,8), %rdi
addq %r15, %r14
movq %r14, %rsi
movl %r15d, %edx
callq 0x19d5
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1e81
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq