LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpl $0x4, %edx
jl 0x7125
movl (%rsi), %eax
cmpl (%rdi), %eax
jne 0x7152
leal -0x4(%rdx), %ecx
addq $0x4, %rsi
addq $0x4, %rdi
cmpl $0x7, %edx
movl %ecx, %edx
jg 0x710b
jmp 0x7127
movl %edx, %ecx
cmpl $0x2, %ecx
jl 0x7144
movzwl (%rsi), %edx
movl $0x1, %eax
cmpw (%rdi), %dx
jne 0x7151
addl $-0x2, %ecx
addq $0x2, %rsi
addq $0x2, %rdi
testl %ecx, %ecx
je 0x7158
movb (%rsi), %cl
xorl %eax, %eax
cmpb (%rdi), %cl
setne %al
retq
movl $0x1, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rax, %r12
testl %r12d, %r12d
je 0x71dd
cmpl $0x1, %r12d
jne 0x7196
movsbl (%r14), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x30c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x71ec
movq %rax, %rbx
testq %rax, %rax
je 0x71dd
leaq 0x2(%r14), %r15
addl $-0x2, %r12d
movslq %r12d, %r12
leaq 0x2(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x31d0
testl %eax, %eax
je 0x71dd
incq %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x71ec
movq %rax, %rbx
testq %rax, %rax
jne 0x71b4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movzbl (%rsi), %eax
movd %eax, %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), %eax
movd %eax, %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 %edi, %ecx
andl $0xf, %ecx
andq $-0x10, %rdi
pxor %xmm2, %xmm2
xorl %esi, %esi
movdqa (%rdi), %xmm3
movdqa %xmm3, %xmm4
pcmpeqb %xmm2, %xmm4
pmovmskb %xmm4, %r8d
shrl %cl, %r8d
movl %r8d, %r9d
notl %r9d
leal -0x1(%r8), %r10d
andl %r9d, %r10d
movdqa %xmm3, %xmm4
pcmpeqb %xmm0, %xmm4
pmovmskb %xmm4, %r11d
pcmpeqb %xmm1, %xmm3
pmovmskb %xmm3, %r9d
shrl %r9d
andl %r11d, %r9d
shrl %cl, %r9d
andl %r10d, %r9d
je 0x727d
movl %ecx, %r8d
addq %rdi, %r8
bsfl %r9d, %eax
addq %r8, %rax
jmp 0x7284
testl %r8d, %r8d
je 0x728e
xorl %eax, %eax
xorl %r8d, %r8d
testb %r8b, %r8b
jne 0x7229
jmp 0x72a7
cmpw %dx, 0xf(%rdi)
leaq 0xf(%rdi), %r9
leaq 0x10(%rdi), %rdi
cmovnel %esi, %ecx
setne %r8b
cmoveq %r9, %rax
jmp 0x7287
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r12
movsbl (%rsi), %ebp
incq %rbx
leaq 0x4(%rsp), %r14
movl %ebp, (%r14)
movq %rbx, %rdi
callq 0x30d0
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3060
movq %rax, %r13
cmpl $0x3, %r13d
jle 0x7338
movq %r12, %rdi
movl %ebp, %esi
callq 0x30c0
testq %rax, %rax
je 0x7333
movq %rax, %r14
movslq %r15d, %r12
leal 0x1(%r12), %eax
cmpl %r15d, %r13d
cmovlq %r13, %rax
movslq %eax, %r13
leaq 0x1(%r14), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x30e0
cmpl %r15d, %eax
jle 0x7369
addq %r13, %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0x30c0
movq %rax, %r14
testq %rax, %rax
jne 0x730a
xorl %r14d, %r14d
jmp 0x7369
movslq %r15d, %r15
xorl %r14d, %r14d
movq %r12, %rdi
movl %ebp, %esi
callq 0x30c0
testq %rax, %rax
je 0x7369
movq %rax, %r13
leaq 0x1(%rax), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x31d0
testl %eax, %eax
jne 0x733e
movq %r13, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x3e67(%rip)      # 0xb7dc
jne 0x79aa
movq %rdi, 0x3e32(%rip)      # 0xb7b0
callq 0x32f0
movl %eax, 0x3e57(%rip)      # 0xb7e0
leaq 0x54(%rip), %rdi        # 0x79e4
callq 0x7f80
movq 0x3e14(%rip), %rdi      # 0xb7b0
xorl %esi, %esi
callq 0x32c0
movb $0x1, 0x3e32(%rip)      # 0xb7dc
testb $0x2, 0x3e27(%rip)      # 0xb7d8
je 0x79e2
leaq 0x13d(%rip), %rbx       # 0x7af7
movl $0x2, %edi
movq %rbx, %rsi
callq 0x3240
movq %rax, 0x3e32(%rip)      # 0xb800
movl $0xf, %edi
movq %rbx, %rsi
callq 0x3240
movq %rax, 0x3e86(%rip)      # 0xb868
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12bc(%rip), %rdi      # 0x8dbd
movl %ebx, %esi
xorl %eax, %eax
callq 0x7c5b
movslq %ebx, %rax
leaq 0x3cdc(%rip), %rcx      # 0xb7f0
movq (%rcx,%rax,8), %rsi
cmpq $0x1, %rsi
je 0x7b3a
testq %rsi, %rsi
je 0x7b49
leaq 0x12f0(%rip), %rdi      # 0x8e1a
xorl %eax, %eax
callq 0x7c5b
movl %ebx, %edi
popq %rbx
jmpq *0x3cb6(%rip)           # 0xb7f0
leaq 0x12c6(%rip), %rdi      # 0x8e07
xorl %eax, %eax
popq %rbx
jmp 0x7c5b
leaq 0x128b(%rip), %rdi      # 0x8ddb
xorl %eax, %eax
callq 0x7c5b
movl $0x1, %edi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3426(%rip), %rax      # 0xafc0
movq (%rax), %rdi
callq 0x796d
movb $0x1, 0x3e5b(%rip)      # 0xba04
movq 0x3c00(%rip), %rcx      # 0xb7b0
leaq 0x1018(%rip), %rdi      # 0x8bcf
movl $0x4, %esi
movl $0x1, %edx
callq 0x33c0
testq %rbx, %rbx
je 0x7be3
movq 0x3bde(%rip), %rdi      # 0xb7b0
leaq 0xffb(%rip), %rsi       # 0x8bd4
movq %rbx, %rdx
xorl %eax, %eax
callq 0x32d0
movq 0x3bc6(%rip), %rsi      # 0xb7b0
movl $0xa, %edi
popq %rbx
jmp 0x3270
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32cc(%rip), %rax      # 0xafc0
movq (%rax), %rdi
callq 0x796d
movq 0x3aad(%rip), %rsi      # 0xb7b0
leaq 0x1138(%rip), %rdi      # 0x8e42
callq 0x3220
movq 0x3a9a(%rip), %rdi      # 0xb7b0
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3290
movl %eax, %ebx
movq 0x3a86(%rip), %rsi      # 0xb7b0
leaq 0xe9c(%rip), %rdi       # 0x8bcd
callq 0x3220
addl $0x3, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0xe0, %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 0x7da4
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 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %rdi, 0x10(%rdx)
leaq 0x8(%rsp), %rdi
callq 0x7887
testl %eax, %eax
jns 0x7ddd
movq $0x0, 0x8(%rsp)
testl %ebx, %ebx
je 0x7e21
movq 0x8(%rsp), %rax
testq %rax, %rax
leaq 0xe38(%rip), %r14       # 0x8c28
cmovneq %rax, %r14
leaq 0xe1c(%rip), %r15       # 0x8c17
movl 0x39b7(%rip), %edx      # 0xb7b8
incl %edx
movl %edx, 0x39af(%rip)      # 0xb7b8
movq 0x39a0(%rip), %rdi      # 0xb7b0
movq %r15, %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x32d0
decl %ebx
jne 0x7dfb
movq 0x8(%rsp), %rdi
callq 0x3250
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7e96
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 0x3913(%rip), %rdi      # 0xb7d0
movq %r10, %rsi
callq 0x7887
testl %eax, %eax
jns 0x7ed4
movq $0x0, 0x38fc(%rip) # 0xb7d0
movb $0x1, 0x38ed(%rip)      # 0xb7c8
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %edi, %eax
negl %eax
cmovsl %edi, %eax
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x40(%rbp)
movq %rax, -0x50(%rbp)
movq $0x1, -0x30(%rbp)
testl %edi, %edi
jns 0x286d3
leaq -0x50(%rbp), %rdi
callq 0x4f468
leaq -0x70(%rbp), %rbx
leaq -0x50(%rbp), %rsi
leaq -0x19(%rbp), %rcx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x60808
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x28712
movq -0x70(%rbp), %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0xe7a0
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x286fc
movq %fs:0x0, %rax
leaq -0x690(%rax), %rbx
leaq -0x68e(%rax), %rdi
leaq -0x60(%rbp), %r15
movq -0x10(%r15), %r14
movq %r14, %rsi
callq 0xe4c0
cmpq %r15, %r14
je 0x2874d
movq -0x60(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0xe530
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq -0x38(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x340d8
leaq -0x88(%rbp), %rdi
movq %rbx, %rsi
callq 0x287de
leaq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x624bc
leaq -0x80(%rbp), %rcx
cmpq %rcx, %rax
jne 0x289d3
leaq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5f410
leaq 0x3f242(%rip), %rdx     # 0x67bcf
leaq -0x58(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x3bd5c
movq -0x50(%rbp), %rdi
incq %rdi
callq 0xe030
movq %rax, %rbx
leaq -0x48(%rbp), %r15
movq -0x10(%r15), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0xe4c0
cmpq %r15, %r14
je 0x289d3
movq -0x48(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0xe530
leaq -0x88(%rbp), %rdi
callq 0x43c84
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x289f8
movq -0x28(%rbp), %rsi
incq %rsi
callq 0xe530
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x28a2b
movq -0x48(%rbp), %rsi
incq %rsi
callq 0xe530
jmp 0x28a2b
jmp 0x28a28
jmp 0x28a28
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x43c84
jmp 0x28a3c
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x28a55
movq -0x28(%rbp), %rsi
incq %rsi
callq 0xe530
movq %rbx, %rdi
callq 0xe950
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %rbx
movq %rdi, %rsi
xorps %xmm0, %xmm0
leaq -0xe0(%rbp), %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movl $0x1, %r12d
movq %r12, 0x20(%r14)
leaq -0xb0(%rbp), %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x4f568
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq %r12, 0x20(%r15)
leaq -0x80(%rbp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4f568
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3be3d
leaq -0x48(%rbp), %r14
leaq -0x21(%rbp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x60808
movq 0x8(%r14), %rbx
testq %rbx, %rbx
je 0x28b13
movq -0x48(%rbp), %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0xe7a0
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x28afd
movq %fs:0x0, %rax
leaq -0x640(%rax), %rbx
leaq -0x63e(%rax), %rdi
leaq -0x38(%rbp), %r15
movq -0x10(%r15), %r14
movq %r14, %rsi
callq 0xe4c0
cmpq %r15, %r14
je 0x28b4e
movq -0x38(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0xe530
movq %rbx, %rax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r14
movq %rdi, %rsi
xorps %xmm0, %xmm0
leaq -0xe0(%rbp), %rbx
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movl $0x1, %r13d
movq %r13, 0x20(%rbx)
leaq -0xb0(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4f568
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq %r13, 0x20(%r15)
leaq -0x80(%rbp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4f568
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movq %r13, 0x20(%r12)
leaq -0x80(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x4fe68
leaq -0x50(%rbp), %rbx
leaq -0x29(%rbp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x60808
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x28c2d
movq -0x50(%rbp), %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0xe7a0
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x28c17
movq %fs:0x0, %rax
leaq -0x5f0(%rax), %rbx
leaq -0x5ee(%rax), %rdi
leaq -0x40(%rbp), %r15
movq -0x10(%r15), %r14
movq %r14, %rsi
callq 0xe4c0
cmpq %r15, %r14
je 0x28c68
movq -0x40(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0xe530
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %rbx
movq %rdi, %rsi
xorps %xmm0, %xmm0
leaq -0xb0(%rbp), %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movl $0x1, %r12d
movq %r12, 0x20(%r14)
leaq -0x80(%rbp), %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x4f568
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq %r12, 0x20(%r15)
leaq -0xe0(%rbp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4f568
movq 0x20(%r14), %rax
cmpl 0x20(%r15), %eax
jne 0x2954a
movl %eax, %eax
testq %rax, %rax
sete %cl
xorps %xmm0, %xmm0
je 0x2954f
movq -0xb0(%rbp), %rcx
cmpq -0x80(%rbp), %rcx
jne 0x29546
shlq $0x3, %rax
movl $0x8, %edx
cmpq %rdx, %rax
sete %cl
je 0x2954f
movq -0xb0(%rbp,%rdx), %rcx
leaq 0x8(%rdx), %rsi
cmpq -0x80(%rbp,%rdx), %rcx
movq %rsi, %rdx
je 0x29528
xorl %ecx, %ecx
jmp 0x2954f
xorl %ecx, %ecx
xorps %xmm0, %xmm0
movzbl %cl, %eax
leaq -0xe0(%rbp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %rax, (%rsi)
movq $0x1, 0x20(%rsi)
leaq -0x48(%rbp), %rbx
leaq -0x21(%rbp), %rcx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x60808
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x295a6
movq -0x48(%rbp), %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0xe7a0
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x29590
movq %fs:0x0, %rax
leaq -0x370(%rax), %rbx
leaq -0x36e(%rax), %rdi
leaq -0x38(%rbp), %r15
movq -0x10(%r15), %r14
movq %r14, %rsi
callq 0xe4c0
cmpq %r15, %r14
je 0x295e1
movq -0x38(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0xe530
movq %rbx, %rax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rsi
pxor %xmm0, %xmm0
leaq -0xf0(%rbp), %rbx
movdqa %xmm0, 0x10(%rbx)
movdqa %xmm0, (%rbx)
movl $0x1, %r13d
movq %r13, 0x20(%rbx)
leaq -0xc0(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4f568
pxor %xmm0, %xmm0
movdqa %xmm0, 0x10(%r15)
movdqa %xmm0, (%r15)
movq %r13, 0x20(%r15)
leaq -0x90(%rbp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4f568
leaq -0x60(%rbp), %rcx
xorps %xmm1, %xmm1
movaps %xmm1, 0x20(%rcx)
pcmpeqd %xmm0, %xmm0
movdqa %xmm0, (%rcx)
movdqa %xmm0, 0x10(%rcx)
movq $0x4, 0x20(%rcx)
movaps %xmm1, (%r12)
movaps %xmm1, 0x10(%r12)
movq %r13, 0x20(%r12)
leaq -0x90(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x53015
leaq -0x60(%rbp), %rbx
leaq -0x29(%rbp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x60808
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x29808
movq -0x60(%rbp), %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0xe7a0
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x297f2
movq %fs:0x0, %rax
leaq -0x2d0(%rax), %rbx
leaq -0x2ce(%rax), %rdi
leaq -0x50(%rbp), %r15
movq -0x10(%r15), %r14
movq %r14, %rsi
callq 0xe4c0
cmpq %r15, %r14
je 0x29843
movq -0x50(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0xe530
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r14
movq %rdi, %rsi
xorps %xmm0, %xmm0
leaq -0x110(%rbp), %rbx
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movw $0x1, %ax
movw %ax, 0x20(%rbx)
movw $0x1, %r12w
xorl %r13d, %r13d
movb %r13b, 0x22(%rbx)
leaq -0xb0(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x54ea2
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movw %r12w, 0x20(%r15)
movb %r13b, 0x22(%r15)
leaq -0x80(%rbp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x54ea2
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movw $0x1, %ax
movw %ax, 0x20(%r12)
movb %r13b, 0x22(%r12)
movzbl 0x22(%rbx), %r12d
leaq -0x80(%rbp), %r14
xorl %edi, %edi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x555a1
cmpq $0x0, (%r14)
cmovnel %r12d, %r13d
movw $0x1, %ax
cmpw %ax, 0x20(%r14)
cmovnel %r12d, %r13d
testb %r12b, %r12b
cmovel %r12d, %r13d
movb %r13b, 0x22(%r14)
leaq -0xe0(%rbp), %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movq $0x1, 0x20(%rbx)
leaq -0x50(%rbp), %rdx
leaq -0x29(%rbp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x56958
leaq -0x50(%rbp), %r14
leaq -0x29(%rbp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x60808
movq 0x8(%r14), %rbx
testq %rbx, %rbx
je 0x29990
movq -0x50(%rbp), %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0xe7a0
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x2997a
movq %fs:0x0, %rax
leaq -0x280(%rax), %rbx
leaq -0x27e(%rax), %rdi
leaq -0x40(%rbp), %r15
movq -0x10(%r15), %r14
movq %r14, %rsi
callq 0xe4c0
cmpq %r15, %r14
je 0x299cb
movq -0x40(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0xe530
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
leaq -0xb0(%rbp), %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movq $0x1, 0x20(%r14)
leaq -0x80(%rbp), %rdx
movq %r14, %rdi
callq 0x4f568
movq %rbx, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0xe730
leaq -0x48(%rbp), %rdx
movq %rax, (%rdx)
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3bfcf
leaq -0x40(%rbp), %r14
leaq -0x19(%rbp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x60808
movq 0x8(%r14), %rbx
testq %rbx, %rbx
je 0x29f07
movq -0x40(%rbp), %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0xe7a0
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x29ef1
movq %fs:0x0, %rax
leaq -0x140(%rax), %rbx
leaq -0x13e(%rax), %rdi
leaq -0x30(%rbp), %r15
movq -0x10(%r15), %r14
movq %r14, %rsi
callq 0xe4c0
cmpq %r15, %r14
je 0x29f42
movq -0x30(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0xe530
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rsi
xorps %xmm0, %xmm0
leaq -0xa0(%rbp), %rbx
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movq $0x1, 0x20(%rbx)
leaq -0x50(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4f568
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movq 0x20(%rbx), %rdx
movl %edx, %eax
movq $0x4, 0x20(%r14)
testl %edx, %edx
je 0x2a3f1
xorl %ecx, %ecx
movq -0xa0(%rbp,%rcx,8), %rsi
notq %rsi
movq %rsi, -0x50(%rbp,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x2a3d9
movq -0x30(%rbp), %rcx
cmpl %ecx, %edx
jae 0x2a41e
movq $-0x1, -0x50(%rbp,%rax,8)
incq %rax
movq -0x30(%rbp), %rcx
movl %ecx, %edx
cmpq %rdx, %rax
jb 0x2a3f9
jmp 0x2a41e
cmpq $0x0, -0x50(%rbp,%rcx,8)
jne 0x2a423
movq %rcx, -0x30(%rbp)
decq %rcx
jne 0x2a412
leaq -0x70(%rbp), %rbx
leaq -0x50(%rbp), %rsi
leaq -0x19(%rbp), %rcx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x60808
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x2a462
movq -0x70(%rbp), %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0xe7a0
movb %al, (%r14,%r15)
incq %r15
cmpq %r15, %rbx
jne 0x2a44c
movq %fs:0x0, %rax
leaq -0x50(%rax), %rbx
leaq -0x4e(%rax), %rdi
leaq -0x60(%rbp), %r15
movq -0x10(%r15), %r14
movq %r14, %rsi
callq 0xe4c0
cmpq %r15, %r14
je 0x2a49d
movq -0x60(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0xe530
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %ebx
leaq 0x10(%rsp), %r13
leaq 0x30(%rsp), %r15
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 0x186e
testl %eax, %eax
je 0x185d
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x1935
testq %rax, %rax
jne 0x1787
decq %rbx
jne 0x1741
jmp 0x185d
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 0x17d3
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 0x17ab
movsbl 0x1(%r14), %eax
testl %eax, %eax
jle 0x180d
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 0x17ea
movsbq 0x1(%r14), %rcx
movl $0x1, %ebp
testq %rcx, %rcx
jle 0x185d
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 0x183b
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_O1/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, 0x783a(%rip)      # 0x90b0
je 0x192b
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 0x3c06
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 *0x77da(%rip)           # 0x90b0
testl %eax, %eax
je 0x191a
andq %r14, -0x8(%r15,%r12,8)
cmpb $0x0, 0x4(%rsp)
jle 0x1911
xorl %ecx, %ecx
xorl %eax, %eax
orq (%r15,%rcx,8), %rax
incq %rcx
cmpq %rcx, %r13
jne 0x18ea
testq %rax, %rax
je 0x1911
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rdx
callq 0x2394
cmpb $0x1, %al
je 0x192e
incq %rbx
cmpq $0x40, %rbx
jne 0x18cb
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 0x191c
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b7d
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 0x1c3c
movb (%r14), %al
addb %al, %al
testb %al, %al
jle 0x19b1
movzbl %al, %eax
xorl %ecx, %ecx
xorl %edx, %edx
orq (%rbx,%rcx,8), %rdx
incq %rcx
cmpq %rcx, %rax
jne 0x199b
xorl %r15d, %r15d
testq %rdx, %rdx
setne %r15b
movq %r15, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b48
andl $0x7f, %edx
shll $0x3, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x1050
testl %ebx, %ebx
jle 0x1b77
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 0x1b50
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1bde
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 0x1baa
movl $0x1, %eax
testq %r11, %r11
jne 0x1c03
movsbl %r8b, %eax
shll $0x6, %eax
cmpl %r9d, %eax
jle 0x1c01
movl %r9d, %eax
sarl $0x6, %eax
cltq
movq (%rsi,%rax,8), %rdi
xorl %eax, %eax
btq %r9, %rdi
setb %al
jmp 0x1c03
xorl %eax, %eax
testb %r8b, %r8b
jle 0x1c36
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 0x1c11
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1fd8
xorl %ecx, %ecx
movb (%rdi,%rcx), %al
movb %al, 0x1(%rsi,%rcx)
incq %rcx
movsbq 0x1(%rdx), %rax
cmpq %rax, %rcx
jl 0x1fc4
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_O1/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 0x1b19
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 0x207d
movsbq (%r15), %rax
testq %rax, %rax
jle 0x207d
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 0x2054
movsbl 0x1(%r15), %eax
testl %eax, %eax
jle 0x20b6
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 0x2094
movsbq 0x1(%r15), %rax
testq %rax, %rax
jle 0x20f3
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 0x20d1
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2165
movq %rsi, %rbx
movq %rdi, %r14
movsbq %r12b, %rcx
movzbl %al, %eax
xorl %edx, %edx
xorl %esi, %esi
orq (%r14,%rdx,8), %rsi
incq %rdx
cmpq %rdx, %rax
jne 0x2129
xorl %eax, %eax
testq %rsi, %rsi
je 0x2167
leaq -0x1(%r12), %rdx
testb %dl, %dl
js 0x2167
movl %edx, %edi
andl $0x7f, %edi
shll $0x3, %edi
movq 0x8(%rbx,%rdi), %rsi
movq (%r14,%rdi), %rdi
cmpq %rdi, %rsi
ja 0x2173
decq %rdx
cmpq %rdi, %rsi
jae 0x2141
jmp 0x2167
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 0x2167
movl %ecx, %edi
andl $0x7f, %edi
shll $0x3, %edi
movq 0x8(%rbx,%rdi), %rsi
movq (%rdx,%rdi), %rdi
cmpq %rdi, %rsi
ja 0x21a0
decq %rcx
cmpq %rdi, %rsi
jae 0x217c
jmp 0x2167
movsbl %r12b, %ecx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x5802
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 0x21fe
movzbl %r12b, %eax
incq %rax
xorl %ecx, %ecx
movq 0x18(%rsp,%rax,8), %rdx
xorq -0x8(%rsp,%rax,8), %rdx
orq %rdx, %rcx
decq %rax
jg 0x21df
xorl %eax, %eax
testq %rcx, %rcx
sete %al
jmp 0x2167
movl $0x1, %eax
jmp 0x2167
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b19
movsbq (%rbx), %rax
leaq (%rsp,%rax,8), %rdi
addq %r15, %r14
movq %r14, %rsi
movl %r15d, %edx
callq 0x1b19
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2101
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b19
leal 0x3f(%r15), %eax
addl $0x7e, %r15d
testl %eax, %eax
cmovnsl %eax, %r15d
sarl $0x6, %r15d
testb %r15b, %r15b
jle 0x2385
movl %r15d, %eax
andl $0x7f, %eax
xorl %ecx, %ecx
xorl %edx, %edx
orq (%rsp,%rcx,8), %rdx
incq %rcx
cmpq %rcx, %rax
jne 0x22b1
xorl %ebp, %ebp
testq %rdx, %rdx
je 0x2387
leaq 0x28(%r14), %rdi
movsbl %r15b, %edx
movq %rsp, %rsi
callq 0x2394
cmpb $0x1, %al
jne 0x2387
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movq %r14, %rdx
callq 0x1935
testq %rax, %rax
je 0x2387
movsbl 0x1(%r14), %eax
testl %eax, %eax
jle 0x2333
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 0x2310
movsbq 0x1(%r14), %rcx
movl $0x1, %ebp
testq %rcx, %rcx
jle 0x2387
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 0x2361
jmp 0x2387
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq