LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/msutil.c
// Function: findbit_1
int
findbit_1(uint8_t const*vec, int len)
{
    int off = 15 & (intptr_t)vec;
    uint8_t const *bp = vec - off;  // Back up to a 16b boundary.
    __m128i zero = _mm_setzero_si128();
    uint16_t m = BYTEDIFF(bp, zero);
    len += off;
        // Mask off trailing bits (tiny vec)
    if (len < 16) m &= ~(-1 << len);  
        // First time through, mask off leading (off) bits
    for (m &= -1 << off; !m && len >= 16; m = BYTEDIFF(bp, zero))
        bp += 16, len -= 16, _mm_prefetch(bp+512, _MM_HINT_NTA);
        // Mask off trailing bits (tail of vec)
    if (len < 16) m &= ~(-1 << len);  
    if (!m) return -1;
    off = bsrl(m);
    return 8*(off + bp - vec) + bsrl(bp[off]);
}

// Assembly:
pushq %rbp
pushq %rbx
movl %edi, %edx
andl $0xf, %edx
movq %rdi, %r8
andq $-0x10, %r8
pxor %xmm0, %xmm0
movdqa (%r8), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %ebx
notl %ebx
addl %edx, %esi
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
movl %esi, %ecx
shll %cl, %r11d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x10, %esi
setl %bpl
notl %r11d
movl $0xffff, %r9d           # imm = 0xFFFF
movl %r11d, %r10d
cmovgel %r9d, %r10d
movl %edx, %ecx
shrl %cl, %r10d
shll %cl, %r10d
andl %ebx, %r10d
testw %r10w, %r10w
setne %cl
orb %bpl, %cl
jne 0x615b
prefetchnta 0x210(%r8)
movdqa 0x10(%r8), %xmm1
addq $0x10, %r8
leal -0x10(%rsi), %ecx
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %r10d
cmpl $0xffff, %r10d          # imm = 0xFFFF
jne 0x614a
cmpl $0x1f, %esi
movl %ecx, %esi
ja 0x611c
notl %r10d
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
shll %cl, %r11d
notl %r11d
jmp 0x615d
movl %esi, %ecx
cmpl $0x10, %ecx
cmovll %r11d, %r9d
andw %r10w, %r9w
je 0x6184
movzwl %r9w, %eax
bsrl %eax, %eax
cltq
leaq (%r8,%rax), %rcx
subl %edi, %ecx
movzbl (%r8,%rax), %eax
bsrl %eax, %eax
leal (%rax,%rcx,8), %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/msutil.c
// Function: chomp
MEMBUF
chomp(MEMBUF buf)
{
    if (buf.ptr)
	while (buf.len > 0 && isspace(buf.ptr[buf.len - 1]))
	    buf.ptr[--buf.len] = 0;
    return  buf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x6220
callq 0x31f0
movq (%rax), %rcx
movsbq -0x1(%rbx,%r14), %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
je 0x6220
movb $0x0, -0x1(%rbx,%r14)
decq %r14
jne 0x6202
xorl %r14d, %r14d
movq %rbx, %rax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/msutil.c
// Function: die
void
die(char const *fmt, ...)
{
    va_list	vargs;
    va_start(vargs, fmt);
    if (*fmt == ':') fputs(getprogname(), stderr);
    vfprintf(stderr, fmt, vargs);
    va_end(vargs);
    if (fmt[strlen(fmt)-1] == ':')
        fprintf(stderr, " %s %s", errname[errno], strerror(errno));
    putc('\n', stderr);
    _exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
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 0x6291
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 %rdi, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
cmpb $0x3a, (%rbx)
jne 0x62cd
callq 0x633a
movq 0x4d16(%rip), %rcx      # 0xafd8
movq (%rcx), %rsi
movq %rax, %rdi
callq 0x3220
movq 0x4d04(%rip), %r15      # 0xafd8
movq (%r15), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x30d0
cmpb $0x3a, -0x1(%rbx,%rax)
jne 0x6323
movq (%r15), %rbx
callq 0x3040
movslq (%rax), %rdi
leaq 0x4efd(%rip), %rax      # 0xb200
movq (%rax,%rdi,8), %r14
callq 0x30a0
leaq 0x20e7(%rip), %rsi      # 0x83fa
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x32d0
movq (%r15), %rsi
movl $0xa, %edi
callq 0x33b0
movl $0x1, %edi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/msutil.c
// Function: getprogname
char const *
getprogname(void)
{
    static char *progname;

    if (!progname) {
        char    buf[999];
        int     len;
        sprintf(buf, "/proc/%d/exe", getpid());
        len = readlink(buf, buf, sizeof(buf));
        if (len < 0 || len == sizeof(buf))
            return NULL;
        buf[len] = 0;
        char    *cp = strrchr(buf, '/');
        progname = strdup(cp ? cp + 1 : buf);
    }

    return  progname;
}

// Assembly:
movq 0x5467(%rip), %rax      # 0xb7a8
testq %rax, %rax
je 0x6347
retq
pushq %rbx
subq $0x3f0, %rsp            # imm = 0x3F0
callq 0x32f0
leaq 0x20a6(%rip), %rsi      # 0x8401
movq %rsp, %rbx
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x3070
movl $0x3e7, %edx            # imm = 0x3E7
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x31e0
testl %eax, %eax
sets %cl
cmpl $0x3e7, %eax            # imm = 0x3E7
sete %dl
orb %cl, %dl
je 0x638f
xorl %eax, %eax
jmp 0x63bc
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movb $0x0, (%rsp,%rax)
movq %rbx, %rdi
movl $0x2f, %esi
callq 0x3200
leaq 0x1(%rax), %rdi
testq %rax, %rax
cmoveq %rbx, %rdi
callq 0x3390
movq %rax, 0x53ec(%rip)      # 0xb7a8
addq $0x3f0, %rsp            # imm = 0x3F0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/msutil.c
// Function: hexdump
void
hexdump(FILE *fp, void const*_buf, int len)
{
    uint8_t const *buf = (uint8_t const*)_buf;
    if (!fp) return;
    int line, i, wid = 32;

    for (line = 0; line < len; line += wid) {
        putc('\t', fp);
        for (i = 0; i < wid; ++i) {
            if (i == wid/2) putc(' ', fp);
            putc(line+i >= len ? ' ' : isprint(buf[line+i]) ? buf[line+i] : '.', fp);
        }
        putc('|', fp);
        for (i = 0; i < wid && line+i < len; ++i) fprintf(fp, " %s%02X", i == wid/2 ? " " : "", buf[line+i]);
        putc('\n', fp);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
movl %edx, 0x4(%rsp)
testl %edx, %edx
setle %cl
orb %al, %cl
jne 0x656f
movq %rsi, %r14
movq %rdi, %r15
movl 0x4(%rsp), %r13d
xorl %r12d, %r12d
movl $0x9, %edi
movq %r15, %rsi
callq 0x33b0
movl $0x20, %ebx
movq %r12, %rbp
cmpq $0x10, %rbx
jne 0x64d0
movl $0x20, %edi
movq %r15, %rsi
callq 0x33b0
movl $0x20, %edi
cmpq %r13, %rbp
jae 0x64f5
callq 0x31f0
movq (%rax), %rcx
movzbl (%r14,%rbp), %eax
testb $0x40, 0x1(%rcx,%rax,2)
movl $0x2e, %edi
je 0x64f5
movl %eax, %edi
movq %r15, %rsi
callq 0x33b0
incq %rbp
decq %rbx
jne 0x64bd
movl $0x7c, %edi
movq %r15, %rsi
callq 0x33b0
movl $0x20, %ebx
movq %r12, %rbp
cmpq %r13, %rbp
jae 0x6553
cmpq $0x10, %rbx
leaq 0x26a4(%rip), %rdx      # 0x8bce
leaq 0x2912(%rip), %rax      # 0x8e43
cmoveq %rax, %rdx
movzbl (%r14,%rbp), %ecx
movq %r15, %rdi
leaq 0x1eca(%rip), %rsi      # 0x840e
xorl %eax, %eax
callq 0x32d0
incq %rbp
decq %rbx
jne 0x651a
movl $0xa, %edi
movq %r15, %rsi
callq 0x33b0
addq $0x20, %r12
cmpl 0x4(%rsp), %r12d
jl 0x64a8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/msutil.c
// Function: refcmp
int
refcmp(MEMREF const a, MEMREF const b)
{
    int     rc, na = nilref(a), nb = nilref(b);
    return na || nb ? na - nb
         : (rc = memcmp(a.ptr, b.ptr, int_min(a.len, b.len))) ? rc
         : (int)a.len - (int)b.len;
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
movq %rsi, %rax
orq %rdi, %rax
sete %r8b
xorl %eax, %eax
movq %rcx, %r9
orq %rdx, %r9
sete %r9b
movl %r8d, %r10d
orb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x66a3
movb %r8b, %bl
movb %r9b, %al
subl %eax, %ebx
jmp 0x66bd
movl %esi, %ebx
subl %ecx, %ebx
cmovll %esi, %ecx
movslq %ecx, %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x30e0
testl %eax, %eax
cmovnel %eax, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/msutil.c
// Function: refdup
char*
refdup(MEMREF r)
{
    if (nilref(r)) return NULL;
    char *cp = malloc(r.len + 1);
    cp[r.len] = 0;
    return memcpy(cp, r.ptr, r.len);
}

// Assembly:
movq %rsi, %rax
orq %rdi, %rax
je 0x66f5
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1(%rsi), %rdi
callq 0x3280
movb $0x0, (%rax,%rbx)
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3160
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/msutil.c
// Function: refsplit
MEMREF *
refsplit(char *text, char sep, int *pcount)
{
    char	*cp;
    int		i, nstrs = 0;
    MEMREF      *strv = NULL;

    if (*text) {
        for (cp = text, nstrs = 1; (cp = strchr(cp, sep)); ++cp) 
            ++nstrs;

        strv = malloc(nstrs * sizeof(MEMREF));

        for (i = 0, cp = text; (cp = strchr(strv[i].ptr = cp, sep)); ++i, ++cp) {
            strv[i].len = cp - strv[i].ptr;
            *cp = 0;
        }

        strv[i].len = strlen(strv[i].ptr);
    }

    if (pcount) 
	*pcount = nstrs;
    return    strv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
je 0x67bb
movq %rdi, %r14
movq %rdx, (%rsp)
movsbl %sil, %ebp
movl %ebp, %esi
callq 0x30c0
testq %rax, %rax
je 0x67c2
movq %rax, %r12
movl $0x1, %r13d
movl $0x10, %r15d
incl %r13d
incq %rax
movq %rax, %rdi
movl %ebp, %esi
callq 0x30c0
addq $0x10, %r15
testq %rax, %rax
jne 0x675b
movq %r15, %rdi
callq 0x3280
movq %rax, %rbx
movq %r14, (%rax)
movq %rax, %r15
testq %r12, %r12
je 0x67db
movq %r12, %rax
subq %r14, %rax
movq %rax, 0x8(%r15)
movb $0x0, (%r12)
movq %r12, %r14
incq %r14
movq %r14, 0x10(%r15)
addq $0x10, %r15
movq %r14, %rdi
movl %ebp, %esi
callq 0x30c0
movq %rax, %r12
testq %rax, %rax
jne 0x678a
jmp 0x67db
xorl %r13d, %r13d
xorl %ebx, %ebx
jmp 0x67eb
movl $0x10, %edi
callq 0x3280
movq %rax, %rbx
movq %r14, (%rax)
movl $0x1, %r13d
movq %rax, %r15
movq %r14, %rdi
callq 0x30d0
movq %rax, 0x8(%r15)
movq (%rsp), %rdx
testq %rdx, %rdx
je 0x67f3
movl %r13d, (%rdx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/msutil.c
// Function: slurp
MEMBUF
slurp(const char *filename)
{
    MEMBUF      ret = NILBUF;
    int         fd = filename && *filename && strcmp(filename, "-") ? open(filename, O_RDONLY) : 0;
    struct stat s;
    if (fd < 0 || fstat(fd, &s))
        goto ERROR;

    if (S_ISREG(s.st_mode)) {
        ret = membuf(s.st_size);
	if (ret.len != (unsigned)read(fd, ret.ptr, ret.len))
            goto ERROR;

    } else {
        int     len, size = 4096;
        ret.ptr = malloc(size + 1);
        for (;0 < (len = read(fd, ret.ptr+ret.len, size-ret.len)); ret.len += len)
            if (len == size - (int)ret.len)
                ret.ptr = realloc(ret.ptr, (size <<= 1) + 1);
        if (len < 0)
            goto ERROR;
        ret.ptr = realloc(ret.ptr, ret.len + 1);
    }

    close(fd);
    ret.ptr[ret.len] = 0;
    return  ret;

ERROR:
    if (fd >= 0) close(fd);
    buffree(ret);
    return NILBUF;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
testq %rdi, %rdi
je 0x6891
movzbl (%rdi), %eax
testl %eax, %eax
je 0x6891
cmpl $0x2d, %eax
jne 0x687d
cmpb $0x0, 0x1(%rdi)
je 0x6891
xorl %r14d, %r14d
xorl %esi, %esi
xorl %eax, %eax
callq 0x3150
movl %eax, %ebx
testl %eax, %eax
jns 0x6893
jmp 0x68ad
xorl %ebx, %ebx
leaq 0x8(%rsp), %rsi
movl %ebx, %edi
callq 0x3350
testl %eax, %eax
je 0x68d3
xorl %r14d, %r14d
movl %ebx, %edi
callq 0x33d0
movq %r14, %rdi
callq 0x3250
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %r14, %rax
movq %r15, %rdx
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xf000, %eax           # imm = 0xF000
andl 0x20(%rsp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x690d
movl 0x38(%rsp), %r15d
testq %r15, %r15
je 0x6989
leal 0x1(%r15), %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x3140
movq %rax, %r14
movslq %r15d, %r15
jmp 0x698f
movl $0x1001, %edi           # imm = 0x1001
callq 0x3280
movq %rax, %r14
movl $0x1000, %edx           # imm = 0x1000
movl %ebx, %edi
movq %rax, %rsi
callq 0x32e0
movq %rax, %r12
testl %r12d, %r12d
jle 0x69a9
movl $0x1000, %r13d          # imm = 0x1000
xorl %r15d, %r15d
movl %r13d, %eax
subl %r15d, %eax
cmpl %r12d, %eax
jne 0x6964
movl %r13d, %ebp
addl %r13d, %ebp
leal 0x1(,%r13,2), %eax
movslq %eax, %rsi
movq %r14, %rdi
callq 0x3340
movq %rax, %r14
movl %ebp, %r13d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
addq %r12, %r15
leaq (%r14,%r15), %rsi
movslq %r13d, %rdx
subq %r15, %rdx
movl %ebx, %edi
callq 0x32e0
movq %rax, %r12
testl %r12d, %r12d
jg 0x693a
jmp 0x69ac
xorl %r14d, %r14d
xorl %r15d, %r15d
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x32e0
movl %eax, %eax
cmpq %rax, %r15
jne 0x68a6
jmp 0x69c4
xorl %r15d, %r15d
testl %r12d, %r12d
js 0x68a6
leaq 0x1(%r15), %rsi
movq %r14, %rdi
callq 0x3340
movq %rax, %r14
movl %ebx, %edi
callq 0x33d0
movb $0x0, (%r14,%r15)
jmp 0x68bb
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/msutil.c
// Function: strim
char *
strim(char *s)
{
    char    *e = s + strlen(s);
    while (e > s && isspace(e[-1])) --e;
    *e = 0;
    while (isspace(*s)) ++s;
    return  s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x30d0
movq %rax, %r14
addq %rbx, %r14
callq 0x31f0
movq %r14, %rcx
cmpq %rbx, %r14
jbe 0x6a07
movq (%rax), %rdx
leaq -0x1(%rcx), %r14
movsbq -0x1(%rcx), %rsi
testb $0x20, 0x1(%rdx,%rsi,2)
jne 0x69ec
movb $0x0, (%rcx)
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x6a10
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/scan.c
// Function: scanbrk
char const*
scanbrk(char const* tgt, char const* chrs)
{
    int         nchrs = strlen(chrs);
    if (nchrs != 2) return strpbrk(tgt, chrs);
    XMM         zero = {}, x;
    XMM         xp0 = xm_fill(chrs[0]), xp1 = xm_fill(chrs[1]);
    unsigned    z, d, f = 15 & (uintptr_t)tgt;

    // Initial unaligned chunk of tgt:
    if (f) {
        z = xm_same(x = xm_load(tgt - f), zero) >> f;
        d = ((xm_same(x, xp0) | xm_same(x, xp1)) >> f) & under(z);
        if (d) return tgt + ffs(d) - 1;
        if (z) return NULL;
        tgt += 16 - f;
    }

    // 16-byte aligned chunks of tgt:
    for (; !(z = xm_same(x = xm_load(tgt), zero)); tgt += 16)
        if ((d = xm_same(x, xp0) | xm_same(x, xp1)))
            return tgt + ffs(d) - 1;

    // Final 0..15 bytes of tgt:
    if ((d = (xm_same(x, xp0) | xm_same(x, xp1)) & under(z)))
        return tgt + ffs(d) - 1;

    return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x30d0
cmpl $0x2, %eax
jne 0x6b9e
movzbl (%r14), %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(%r14), %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]
movl %ebx, %ecx
andl $0xf, %ecx
je 0x6bbe
movq %rbx, %rax
andq $-0x10, %rax
movdqa (%rax), %xmm2
pxor %xmm3, %xmm3
pcmpeqb %xmm2, %xmm3
pmovmskb %xmm3, %eax
shrl %cl, %eax
movdqa %xmm2, %xmm3
pcmpeqb %xmm0, %xmm3
pcmpeqb %xmm1, %xmm2
por %xmm3, %xmm2
pmovmskb %xmm2, %esi
shrl %cl, %esi
leal 0x7fff(%rax), %edi
movl %eax, %edx
notl %edx
andl %edi, %edx
andl %esi, %edx
je 0x6bb0
bsfl %edx, %eax
jmp 0x6c23
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3360
testl %eax, %eax
jne 0x6c1c
movl $0x10, %eax
subl %ecx, %eax
addq %rax, %rbx
movdqa (%rbx), %xmm2
pxor %xmm3, %xmm3
movdqa %xmm2, %xmm4
pcmpeqb %xmm3, %xmm4
pmovmskb %xmm4, %eax
testl %eax, %eax
jne 0x6bf9
movdqa %xmm2, %xmm4
pcmpeqb %xmm0, %xmm4
pcmpeqb %xmm1, %xmm2
por %xmm4, %xmm2
pmovmskb %xmm2, %eax
testl %eax, %eax
jne 0x6c20
movdqa 0x10(%rbx), %xmm2
addq $0x10, %rbx
jmp 0x6bc6
movzwl %ax, %eax
pcmpeqb %xmm2, %xmm0
pcmpeqb %xmm2, %xmm1
por %xmm0, %xmm1
pmovmskb %xmm1, %ecx
leal -0x1(%rax), %edx
notl %eax
andl %edx, %eax
andl %ecx, %eax
je 0x6c1c
bsfl %eax, %eax
jmp 0x6c23
xorl %ebx, %ebx
jmp 0x6c26
bsfl %eax, %eax
addq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/scan.c
// Function: scancmp
int
scancmp(char const* s, char const* t)
{
    XMM         xs, zero = {};
    unsigned    m, z, f = 15 & (intptr_t) s;

    if (f) {
        z = xm_same(xs = xm_load(s - f), zero) >> f;
        m = under(z) & (xm_diff(xs, xm_loud(t - f)) >> f) & under(z);
        if (m) return m = ffs(m) - 1, s[m] - t[m];
        if (z) return 0;
        s += 16 - f, t += 16 - f;
    }

    for (;!(z = xm_same(xs = xm_load(s), zero)); s += 16, t +=16)
        if ((m = xm_diff(xs, xm_loud(t))))
            return m = ffs(m) - 1, s[m] - t[m];

    m = xm_diff(xm_load(s), xm_loud(t)) & under(z);
    return m ? m = ffs(m) - 1, s[m] - t[m] : 0;
}

// Assembly:
movl %edi, %ecx
andl $0xf, %ecx
je 0x6c9c
movl %edi, %edx
movq %rdi, %rax
andq $-0x10, %rax
movdqa (%rax), %xmm0
pxor %xmm1, %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %eax
shrl %cl, %eax
andl $0xf, %edx
leal 0x7fff(%rax), %r8d
movl %eax, %r9d
notl %r9d
andl %r8d, %r9d
movq %rsi, %r8
subq %rdx, %r8
movdqu (%r8), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %edx
xorl $0xffff, %edx           # imm = 0xFFFF
shrl %cl, %edx
andl %r9d, %edx
je 0x6c8b
bsfl %edx, %eax
jmp 0x6d03
testl %eax, %eax
jne 0x6cfb
movl $0x10, %eax
subl %ecx, %eax
addq %rax, %rdi
addq %rax, %rsi
movdqa (%rdi), %xmm0
pxor %xmm1, %xmm1
movdqa %xmm0, %xmm2
pcmpeqb %xmm1, %xmm2
pmovmskb %xmm2, %eax
testl %eax, %eax
jne 0x6cd6
movdqu (%rsi), %xmm2
pcmpeqb %xmm0, %xmm2
pmovmskb %xmm2, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jne 0x6cfe
addq $0x10, %rsi
movdqa 0x10(%rdi), %xmm0
addq $0x10, %rdi
jmp 0x6ca4
movzwl %ax, %eax
movdqu (%rsi), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %ecx
xorl $0xffff, %ecx           # imm = 0xFFFF
leal -0x1(%rax), %edx
notl %eax
andl %edx, %eax
andl %ecx, %eax
je 0x6cfb
bsfl %eax, %eax
jmp 0x6d03
xorl %eax, %eax
retq
notl %eax
bsfl %eax, %eax
addq %rax, %rdi
addq %rax, %rsi
movsbl (%rdi), %eax
movsbl (%rsi), %ecx
subl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6f0b
movl (%rsi), %eax
cmpl (%rdi), %eax
jne 0x6f38
leal -0x4(%rdx), %ecx
addq $0x4, %rsi
addq $0x4, %rdi
cmpl $0x7, %edx
movl %ecx, %edx
jg 0x6ef1
jmp 0x6f0d
movl %edx, %ecx
cmpl $0x2, %ecx
jl 0x6f2a
movzwl (%rsi), %edx
movl $0x1, %eax
cmpw (%rdi), %dx
jne 0x6f37
addl $-0x2, %ecx
addq $0x2, %rsi
addq $0x2, %rdi
testl %ecx, %ecx
je 0x6f3e
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_O3/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 0x6fc5
cmpl $0x1, %r12d
jne 0x6f7c
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 0x6fd4
testq %rax, %rax
je 0x6fc3
movq %rax, %rbx
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 0x6fc5
incq %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6fd4
movq %rax, %rbx
testq %rax, %rax
jne 0x6f9a
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x706a
testl %esi, %esi
jne 0x7076
leaq 0x10(%rax), %rsi
xorl %ecx, %ecx
cmpw %dx, 0xf(%rax)
movq %rsi, %rax
jne 0x7012
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_O3/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 0x7109
movq %r12, %rdi
movl %ebp, %esi
callq 0x30c0
testq %rax, %rax
je 0x7104
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 0x713a
addq %r13, %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0x30c0
movq %rax, %r14
testq %rax, %rax
jne 0x70db
xorl %r14d, %r14d
jmp 0x713a
movslq %r15d, %r15
xorl %r14d, %r14d
movq %r12, %rdi
movl %ebp, %esi
callq 0x30c0
testq %rax, %rax
je 0x713a
movq %rax, %r13
leaq 0x1(%rax), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x31d0
testl %eax, %eax
jne 0x710f
movq %r13, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x408c(%rip)      # 0xb7dc
jne 0x7785
movq %rdi, 0x4057(%rip)      # 0xb7b0
callq 0x32f0
movl %eax, 0x407c(%rip)      # 0xb7e0
leaq 0x54(%rip), %rdi        # 0x77bf
callq 0x7d60
movq 0x4039(%rip), %rdi      # 0xb7b0
xorl %esi, %esi
callq 0x32c0
movb $0x1, 0x4057(%rip)      # 0xb7dc
testb $0x2, 0x404c(%rip)      # 0xb7d8
je 0x77bd
leaq 0x142(%rip), %rbx       # 0x78d7
movl $0x2, %edi
movq %rbx, %rsi
callq 0x3240
movq %rax, 0x4057(%rip)      # 0xb800
movl $0xf, %edi
movq %rbx, %rsi
callq 0x3240
movq %rax, 0x40ab(%rip)      # 0xb868
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x14dc(%rip), %rdi      # 0x8dbd
movl %ebx, %esi
xorl %eax, %eax
callq 0x7a3b
movslq %ebx, %rax
leaq 0x3efc(%rip), %rcx      # 0xb7f0
movq (%rcx,%rax,8), %rsi
cmpq $0x1, %rsi
je 0x791a
testq %rsi, %rsi
je 0x7929
leaq 0x1510(%rip), %rdi      # 0x8e1a
xorl %eax, %eax
callq 0x7a3b
movl %ebx, %edi
popq %rbx
jmpq *0x3ed6(%rip)           # 0xb7f0
leaq 0x14e6(%rip), %rdi      # 0x8e07
xorl %eax, %eax
popq %rbx
jmp 0x7a3b
leaq 0x14ab(%rip), %rdi      # 0x8ddb
xorl %eax, %eax
callq 0x7a3b
movl $0x1, %edi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3646(%rip), %rax      # 0xafc0
movq (%rax), %rdi
callq 0x7748
movb $0x1, 0x407b(%rip)      # 0xba04
movq 0x3e20(%rip), %rcx      # 0xb7b0
leaq 0x1238(%rip), %rdi      # 0x8bcf
movl $0x4, %esi
movl $0x1, %edx
callq 0x33c0
testq %rbx, %rbx
je 0x79c3
movq 0x3dfe(%rip), %rdi      # 0xb7b0
leaq 0x121b(%rip), %rsi      # 0x8bd4
movq %rbx, %rdx
xorl %eax, %eax
callq 0x32d0
movq 0x3de6(%rip), %rsi      # 0xb7b0
movl $0xa, %edi
popq %rbx
jmp 0x3270
// File: /workspace/github_cpp_makefile_star2_O3/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 0x34ec(%rip), %rax      # 0xafc0
movq (%rax), %rdi
callq 0x7748
movq 0x3ccd(%rip), %rsi      # 0xb7b0
leaq 0x1358(%rip), %rdi      # 0x8e42
callq 0x3220
movq 0x3cba(%rip), %rdi      # 0xb7b0
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3290
movl %eax, %ebx
movq 0x3ca6(%rip), %rsi      # 0xb7b0
leaq 0x10bc(%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_O3/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 0x7b86
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 0x7662
testl %eax, %eax
js 0x7bbd
movq 0x8(%rsp), %r14
jmp 0x7bc0
xorl %r14d, %r14d
testl %ebx, %ebx
je 0x7bff
testq %r14, %r14
leaq 0x105a(%rip), %r15      # 0x8c28
cmovneq %r14, %r15
leaq 0x103e(%rip), %r12      # 0x8c17
movl 0x3bd9(%rip), %edx      # 0xb7b8
incl %edx
movl %edx, 0x3bd1(%rip)      # 0xb7b8
movq 0x3bc2(%rip), %rdi      # 0xb7b0
movq %r12, %rsi
movq %r15, %rcx
xorl %eax, %eax
callq 0x32d0
decl %ebx
jne 0x7bd9
movq %r14, %rdi
callq 0x3250
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7c74
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 0x3b35(%rip), %rdi      # 0xb7d0
movq %r10, %rsi
callq 0x7662
testl %eax, %eax
jns 0x7cb2
movq $0x0, 0x3b1e(%rip) # 0xb7d0
movb $0x1, 0x3b0f(%rip)      # 0xb7c8
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2822b
leaq -0x50(%rbp), %rdi
callq 0x4e8ec
leaq -0x70(%rbp), %r14
leaq -0x50(%rbp), %rsi
leaq -0x19(%rbp), %rcx
movq %r14, %rdi
movl $0x8, %edx
callq 0x5fc4e
movq (%r14), %rbx
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x2826d
xorl %r15d, %r15d
movsbl (%rbx,%r15), %edi
callq 0xe7a0
movb %al, (%rbx,%r15)
incq %r15
cmpq %r15, %r14
jne 0x28253
movq -0x70(%rbp), %rbx
movq %fs:0x0, %rax
leaq -0x690(%rax), %r14
leaq -0x68e(%rax), %rdi
movq %rbx, %rsi
callq 0xe4c0
leaq -0x60(%rbp), %rax
cmpq %rax, %rbx
je 0x282a4
movq -0x60(%rbp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0xe530
movq %r14, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x33a06
leaq -0x88(%rbp), %rdi
movq %rbx, %rsi
callq 0x28335
leaq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x618f4
leaq -0x80(%rbp), %rcx
cmpq %rcx, %rax
jne 0x2852a
leaq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5e88a
leaq 0x3f6eb(%rip), %rdx     # 0x67bcf
leaq -0x58(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x3b54a
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 0x2852a
movq -0x48(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0xe530
leaq -0x88(%rbp), %rdi
callq 0x43308
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2854f
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 0x28582
movq -0x48(%rbp), %rsi
incq %rsi
callq 0xe530
jmp 0x28582
jmp 0x2857f
jmp 0x2857f
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x43308
jmp 0x28593
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x285ac
movq -0x28(%rbp), %rsi
incq %rsi
callq 0xe530
movq %rbx, %rdi
callq 0xe950
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4ea1a
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 0x4ea1a
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3b62b
leaq -0x48(%rbp), %r14
leaq -0x21(%rbp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x5fc4e
movq (%r14), %rbx
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x2866d
xorl %r15d, %r15d
movsbl (%rbx,%r15), %edi
callq 0xe7a0
movb %al, (%rbx,%r15)
incq %r15
cmpq %r15, %r14
jne 0x28653
movq -0x48(%rbp), %rbx
movq %fs:0x0, %rax
leaq -0x640(%rax), %r14
leaq -0x63e(%rax), %rdi
movq %rbx, %rsi
callq 0xe4c0
leaq -0x38(%rbp), %rax
cmpq %rax, %rbx
je 0x286a4
movq -0x38(%rbp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0xe530
movq %r14, %rax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4ea1a
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 0x4ea1a
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 0x4f3e4
leaq -0x50(%rbp), %r15
leaq -0x29(%rbp), %rcx
movq %r15, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x5fc4e
movq (%r15), %rbx
movq 0x8(%r15), %r14
testq %r14, %r14
je 0x28786
xorl %r15d, %r15d
movsbl (%rbx,%r15), %edi
callq 0xe7a0
movb %al, (%rbx,%r15)
incq %r15
cmpq %r15, %r14
jne 0x2876c
movq -0x50(%rbp), %rbx
movq %fs:0x0, %rax
leaq -0x5f0(%rax), %r14
leaq -0x5ee(%rax), %rdi
movq %rbx, %rsi
callq 0xe4c0
leaq -0x40(%rbp), %rax
cmpq %rax, %rbx
je 0x287bd
movq -0x40(%rbp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0xe530
movq %r14, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 -0xe0(%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 0x4ea1a
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq %r12, 0x20(%r15)
leaq -0xb0(%rbp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4ea1a
movq 0x20(%r14), %rax
cmpl 0x20(%r15), %eax
jne 0x2907d
movl %eax, %eax
testq %rax, %rax
xorps %xmm0, %xmm0
je 0x29088
shlq $0x3, %rax
xorl %ecx, %ecx
movq -0xe0(%rbp,%rcx), %rdx
cmpq -0x80(%rbp,%rcx), %rdx
jne 0x29085
addq $0x8, %rcx
cmpq %rcx, %rax
jne 0x29063
jmp 0x29088
xorl %r12d, %r12d
xorps %xmm0, %xmm0
jmp 0x29088
xorl %r12d, %r12d
leaq -0xb0(%rbp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %r12, (%rsi)
movq $0x1, 0x20(%rsi)
leaq -0x48(%rbp), %r14
leaq -0x21(%rbp), %rcx
movq %r14, %rdi
movl $0x8, %edx
callq 0x5fc4e
movq (%r14), %rbx
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x290df
xorl %r15d, %r15d
movsbl (%rbx,%r15), %edi
callq 0xe7a0
movb %al, (%rbx,%r15)
incq %r15
cmpq %r15, %r14
jne 0x290c5
movq -0x48(%rbp), %rbx
movq %fs:0x0, %rax
leaq -0x370(%rax), %r14
leaq -0x36e(%rax), %rdi
movq %rbx, %rsi
callq 0xe4c0
leaq -0x38(%rbp), %rax
cmpq %rax, %rbx
je 0x29116
movq -0x38(%rbp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0xe530
movq %r14, %rax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4ea1a
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 0x4ea1a
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 0x525b5
leaq -0x60(%rbp), %r15
leaq -0x29(%rbp), %rcx
movq %r15, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x5fc4e
movq (%r15), %rbx
movq 0x8(%r15), %r14
testq %r14, %r14
je 0x2933f
xorl %r15d, %r15d
movsbl (%rbx,%r15), %edi
callq 0xe7a0
movb %al, (%rbx,%r15)
incq %r15
cmpq %r15, %r14
jne 0x29325
movq -0x60(%rbp), %rbx
movq %fs:0x0, %rax
leaq -0x2d0(%rax), %r14
leaq -0x2ce(%rax), %rdi
movq %rbx, %rsi
callq 0xe4c0
leaq -0x50(%rbp), %rax
cmpq %rax, %rbx
je 0x29376
movq -0x50(%rbp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0xe530
movq %r14, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0xf8, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rsi
xorps %xmm0, %xmm0
leaq -0x120(%rbp), %rbx
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movw $0x1, %r13w
movw %r13w, 0x20(%rbx)
xorl %r14d, %r14d
movb %r14b, 0x22(%rbx)
leaq -0xc0(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x5445a
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movw %r13w, 0x20(%r15)
movb %r14b, 0x22(%r15)
leaq -0x90(%rbp), %r12
movq %r15, %rdi
movq -0x38(%rbp), %rsi
movq %r12, %rdx
callq 0x5445a
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movw %r13w, 0x20(%r12)
movb %r14b, 0x22(%r12)
movb 0x22(%rbx), %r12b
leaq -0x90(%rbp), %r14
xorl %edi, %edi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x54bbc
cmpw %r13w, 0x20(%r14)
setne %al
movl %r12d, %ecx
xorb $0x1, %cl
orb %al, %cl
cmpq $0x0, (%r14)
setne %al
orb %cl, %al
andb %r12b, %al
movb %al, 0x22(%r14)
leaq -0xf0(%rbp), %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
movq $0x1, 0x20(%rbx)
leaq -0x58(%rbp), %rdx
leaq -0x29(%rbp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x55ede
leaq -0x58(%rbp), %r14
leaq -0x29(%rbp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x5fc4e
movq (%r14), %rbx
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x294c6
xorl %r15d, %r15d
movsbl (%rbx,%r15), %edi
callq 0xe7a0
movb %al, (%rbx,%r15)
incq %r15
cmpq %r15, %r14
jne 0x294ac
movq -0x58(%rbp), %rbx
movq %fs:0x0, %rax
leaq -0x280(%rax), %r14
leaq -0x27e(%rax), %rdi
movq %rbx, %rsi
callq 0xe4c0
leaq -0x48(%rbp), %rax
cmpq %rax, %rbx
je 0x294fd
movq -0x48(%rbp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0xe530
movq %r14, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4ea1a
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 0x3b7b3
leaq -0x40(%rbp), %r14
leaq -0x19(%rbp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x5fc4e
movq (%r14), %rbx
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x29a34
xorl %r15d, %r15d
movsbl (%rbx,%r15), %edi
callq 0xe7a0
movb %al, (%rbx,%r15)
incq %r15
cmpq %r15, %r14
jne 0x29a1a
movq -0x40(%rbp), %rbx
movq %fs:0x0, %rax
leaq -0x140(%rax), %r14
leaq -0x13e(%rax), %rdi
movq %rbx, %rsi
callq 0xe4c0
leaq -0x30(%rbp), %rax
cmpq %rax, %rbx
je 0x29a6b
movq -0x30(%rbp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0xe530
movq %r14, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4ea1a
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 0x29f06
xorl %ecx, %ecx
movq -0xa0(%rbp,%rcx,8), %rsi
notq %rsi
movq %rsi, -0x50(%rbp,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x29ee8
movq -0x30(%rbp), %rcx
jmp 0x29f0b
movl $0x4, %ecx
cmpl %ecx, %edx
jae 0x29f34
movq $-0x1, -0x50(%rbp,%rax,8)
incq %rax
movq -0x30(%rbp), %rcx
movl %ecx, %edx
cmpq %rdx, %rax
jb 0x29f0f
jmp 0x29f34
cmpq $0x0, -0x50(%rbp,%rcx,8)
jne 0x29f39
movq %rcx, -0x30(%rbp)
decq %rcx
jne 0x29f28
leaq -0x70(%rbp), %r14
leaq -0x50(%rbp), %rsi
leaq -0x19(%rbp), %rcx
movq %r14, %rdi
movl $0x8, %edx
callq 0x5fc4e
movq (%r14), %rbx
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x29f7b
xorl %r15d, %r15d
movsbl (%rbx,%r15), %edi
callq 0xe7a0
movb %al, (%rbx,%r15)
incq %r15
cmpq %r15, %r14
jne 0x29f61
movq -0x70(%rbp), %rbx
movq %fs:0x0, %rax
leaq -0x50(%rax), %r14
leaq -0x4e(%rax), %rdi
movq %rbx, %rsi
callq 0xe4c0
leaq -0x60(%rbp), %rax
cmpq %rax, %rbx
je 0x29fb2
movq -0x60(%rbp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0xe530
movq %r14, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq