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

#   if __SIZEOF_SIZE_T__ == 8
    if (len >= (int)sizeof(uint32_t)) {
        if (*(uint32_t*)src != *(uint32_t*)dst)
            return 1;
        len -= sizeof(uint32_t), src += sizeof(uint32_t), dst += sizeof(uint32_t);
    }
#   endif

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jl 0x7426
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
je 0x7401
movl $0x1, -0x4(%rbp)
jmp 0x74d9
movslq -0x1c(%rbp), %rax
subq $0x8, %rax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x73df
cmpl $0x4, -0x1c(%rbp)
jl 0x7469
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
je 0x7446
movl $0x1, -0x4(%rbp)
jmp 0x74d9
movslq -0x1c(%rbp), %rax
subq $0x4, %rax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
cmpl $0x2, -0x1c(%rbp)
jl 0x74ad
movq -0x18(%rbp), %rax
movswl (%rax), %eax
movq -0x10(%rbp), %rcx
movswl (%rcx), %ecx
cmpl %ecx, %eax
je 0x748a
movl $0x1, -0x4(%rbp)
jmp 0x74d9
movslq -0x1c(%rbp), %rax
subq $0x2, %rax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
je 0x74ce
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: ctSkennerton[P]fxtract/util/msutil.c
// Function: vec_free
void
vec_free(VEC* v)
{
    if (!v) return;
    vec_resize(v, 0);
    free(v->ptr);
    free(v);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7545
jmp 0x7566
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x7570
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3240
movq -0x8(%rbp), %rdi
callq 0x3240
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: ctSkennerton[P]fxtract/util/msutil.c
// Function: vec_resize
void
vec_resize(VEC* v, int limit)
{
    if (v->dtor)
        while (v->count > limit)
            v->dtor(vec_pop(v), v->context);

    v->ptr = realloc(v->ptr, v->width * (v->limit = limit));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x75c4
jmp 0x758c
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
jle 0x75c2
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7740
movq -0x18(%rbp), %rcx
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movb $0x0, %al
callq *%rcx
jmp 0x758c
jmp 0x75c4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rdx
movl %ecx, (%rdx)
imull %ecx, %eax
movslq %eax, %rsi
callq 0x3330
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ctSkennerton[P]fxtract/util/msutil.c
// Function: STRcat
STR
STRcat(STR str, char const *s)
{
    int     size = vec_count(str);
    vec_allow(str, size + strlen(s) + 1);
    strcpy(STRptr(str) + size, s);
    return  str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7810
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30d0
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
addq $0x1, %rax
movl %eax, %esi
callq 0x74e0
movq -0x8(%rbp), %rdi
callq 0x7840
movq %rax, %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x31b0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ctSkennerton[P]fxtract/util/msutil.c
// Function: addr_part
MEMREF
addr_part(MEMREF r)
{
    const char  *dp, *cp = memchr(r.ptr, '(', r.len);
    size_t        len = cp ? (size_t)(cp - r.ptr) : r.len;

    if ((cp = memchr(r.ptr, '<', len)) && (dp = memchr(cp, '>', r.ptr+len-cp))) {
        len = dp - cp - 1;
        ++cp;
    } else {
        cp = r.ptr;
    }
        // Trim leading space
    while (len > 0 && isspace(cp[len-1])) --len;
    while (len > 0 && isspace(*cp)) ++cp, --len;
        // (cp) should match /.[@%]./
    return    memref(cp, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x28, %esi
callq 0x3200
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x78ee
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0x78f6
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rdx
movl $0x3c, %esi
callq 0x3200
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x7962
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rdx
addq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rax
subq %rax, %rdx
movl $0x3e, %esi
callq 0x3200
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x7962
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x796a
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x796c
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x41(%rbp)
jbe 0x79a5
callq 0x31e0
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rdx
subq $0x1, %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x79ae
jmp 0x79bc
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x796c
jmp 0x79be
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x42(%rbp)
jbe 0x79ee
callq 0x31e0
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x79f7
jmp 0x7a11
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x79be
movq -0x30(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x7a40
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ctSkennerton[P]fxtract/util/msutil.c
// Function: belch
int
belch(char const *filename, MEMREF data)
{
    FILE    *fp = fopen(filename, "w");
    if (!fp) return 0;
    int ret = fwrite(data.ptr, data.len, 1, fp);
    fclose(fp);
    return  ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x4949(%rip), %rsi      # 0xc3f8
callq 0x3220
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x7ac8
movl $0x0, -0x4(%rbp)
jmp 0x7af0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rcx
movl $0x1, %edx
callq 0x33b0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x31c0
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ctSkennerton[P]fxtract/util/msutil.c
// Function: bitwid
int
bitwid(unsigned u)
{
#ifdef __BSD_VISIBLE
    int	ret = fls(u);
    if (u > 1U << ret)
	++ret;
#else
    if (!u) return 0;
    int        ret;
    if (u & 0xFFFF0000) u >>= 16, ret = 17; else ret = 1;
    if (u & 0x0000FF00) u >>=  8, ret += 8;
    if (u & 0x000000F0) u >>=  4, ret += 4;
    if (u & 0x0000000C) u >>=  2, ret += 2;
    if (u & 0x00000002) ret++;
#endif
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x7b19
movl $0x0, -0x4(%rbp)
jmp 0x7bb4
movl -0x8(%rbp), %eax
andl $0xffff0000, %eax       # imm = 0xFFFF0000
cmpl $0x0, %eax
je 0x7b38
movl -0x8(%rbp), %eax
shrl $0x10, %eax
movl %eax, -0x8(%rbp)
movl $0x11, -0xc(%rbp)
jmp 0x7b3f
movl $0x1, -0xc(%rbp)
movl -0x8(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
cmpl $0x0, %eax
je 0x7b5e
movl -0x8(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
andl $0xf0, %eax
cmpl $0x0, %eax
je 0x7b7d
movl -0x8(%rbp), %eax
shrl $0x4, %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
andl $0xc, %eax
cmpl $0x0, %eax
je 0x7b9a
movl -0x8(%rbp), %eax
shrl $0x2, %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x7bae
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: ctSkennerton[P]fxtract/util/msutil.c
// Function: fileref
MEMREF
fileref(char const *filename)
{
    MEMREF  mr = NILREF;
    int     fd = open(filename, O_RDONLY, 0);
    if (fd >= 0) {
        mr.len = lseek(fd, 0L, SEEK_END);
        mr.ptr = mmap(NULL, mr.len, PROT_READ, MAP_SHARED|MAP_NOCORE, fd, 0);
        close(fd);
    }

    return fd < 0 || mr.len <= 0 || mr.ptr == MAP_FAILED ? NILREF : mr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3110
movq -0x18(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
movb $0x0, %al
callq 0x3150
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x80c1
movl -0x2c(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x3390
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movl -0x2c(%rbp), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x1, %ecx
movq %r9, %rdi
movl %ecx, %edx
callq 0x3370
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %edi
callq 0x33c0
cmpl $0x0, -0x2c(%rbp)
jl 0x80db
cmpq $0x0, -0x20(%rbp)
jbe 0x80db
movq $-0x1, %rax
cmpq %rax, -0x28(%rbp)
jne 0x80ed
movq $0x0, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
jmp 0x80fd
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ctSkennerton[P]fxtract/util/msutil.c
// Function: bufcat
void
bufcat(MEMBUF* bp, MEMREF r)
{
    if (nilref(r)) return;
    bp->ptr = realloc(bp->ptr, bp->len + r.len + 1);
    bp->ptr[bp->len + r.len] = 0;
    memcpy(bp->ptr + bp->len, r.ptr, r.len);
    bp->len += r.len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x8600
cmpl $0x0, %eax
je 0x8588
jmp 0x85f1
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
addq -0x8(%rbp), %rsi
addq $0x1, %rsi
callq 0x3330
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq -0x8(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
addq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x3160
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x86a7
jmp 0x8649
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x21(%rbp)
jbe 0x8682
callq 0x31e0
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x868b
jmp 0x86a5
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x18(%rbp)
movb $0x0, -0x1(%rax,%rcx)
jmp 0x8649
jmp 0x86a7
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x86f5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x8763
callq 0x8820
movq %rax, %rdi
movq 0x787d(%rip), %rax      # 0xffd8
movq (%rax), %rsi
callq 0x3210
movq 0x786e(%rip), %rax      # 0xffd8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x3280
leaq -0x20(%rbp), %rax
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30d0
movq %rax, %rcx
movq -0xd8(%rbp), %rax
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
jne 0x87ff
movq 0x7828(%rip), %rax      # 0xffd8
movq (%rax), %rax
movq %rax, -0xe8(%rbp)
callq 0x3040
movslq (%rax), %rcx
leaq 0x7a37(%rip), %rax      # 0x10200
movq (%rax,%rcx,8), %rax
movq %rax, -0xe0(%rbp)
callq 0x3040
movl (%rax), %edi
callq 0x30a0
movq -0xe8(%rbp), %rdi
movq -0xe0(%rbp), %rdx
movq %rax, %rcx
leaq 0x3c02(%rip), %rsi      # 0xc3fa
movb $0x0, %al
callq 0x32c0
movq 0x77d2(%rip), %rax      # 0xffd8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x33a0
movl $0x1, %edi
callq 0x3320
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
cmpq $0x0, 0x7f85(%rip)      # 0x107b8
jne 0x8909
leaq -0x3f0(%rbp), %rax
movq %rax, -0x408(%rbp)
callq 0x32e0
movq -0x408(%rbp), %rdi
movl %eax, %edx
leaq 0x3ba5(%rip), %rsi      # 0xc401
movb $0x0, %al
callq 0x3070
leaq -0x3f0(%rbp), %rdi
leaq -0x3f0(%rbp), %rsi
movl $0x3e7, %edx            # imm = 0x3E7
callq 0x31d0
movl %eax, -0x3f4(%rbp)
cmpl $0x0, -0x3f4(%rbp)
jl 0x8899
movslq -0x3f4(%rbp), %rax
cmpq $0x3e7, %rax            # imm = 0x3E7
jne 0x88a3
movq $0x0, -0x8(%rbp)
jmp 0x8914
movslq -0x3f4(%rbp), %rax
movb $0x0, -0x3f0(%rbp,%rax)
leaq -0x3f0(%rbp), %rdi
movl $0x2f, %esi
callq 0x31f0
movq %rax, -0x400(%rbp)
cmpq $0x0, -0x400(%rbp)
je 0x88e8
movq -0x400(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x410(%rbp)
jmp 0x88f6
leaq -0x3f0(%rbp), %rax
movq %rax, -0x410(%rbp)
movq -0x410(%rbp), %rdi
callq 0x3380
movq %rax, 0x7eaf(%rip)      # 0x107b8
movq 0x7ea8(%rip), %rax      # 0x107b8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ctSkennerton[P]fxtract/util/msutil.c
// Function: fopenf
FILE *
fopenf(char const *mode, char const *fmt, ...)
{
    char	*path;
    va_list	vargs;
    va_start(vargs, fmt);
    vasprintf(&path, fmt, vargs);
    va_end(vargs);
    FILE    *fp = fopen(path, mode);
    free(path);
    return  fp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x896b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x31a0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3220
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3240
movq -0x38(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8a17
jmp 0x8ba1
movl $0x20, -0x2c(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8ba1
movq -0x8(%rbp), %rsi
movl $0x9, %edi
callq 0x33a0
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x8af9
movl -0x28(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jne 0x8a7a
movq -0x8(%rbp), %rsi
movl $0x20, %edi
callq 0x33a0
movl -0x24(%rbp), %eax
addl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x8a8f
movl $0x20, %eax
movl %eax, -0x34(%rbp)
jmp 0x8adf
callq 0x31e0
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %edx
addl -0x28(%rbp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x8acf
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x38(%rbp)
jmp 0x8ad9
movl $0x2e, %eax
movl %eax, -0x38(%rbp)
jmp 0x8ad9
movl -0x38(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x33a0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x8a46
movq -0x8(%rbp), %rsi
movl $0x7c, %edi
callq 0x33a0
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %ecx
xorl %eax, %eax
cmpl -0x2c(%rbp), %ecx
movb %al, -0x39(%rbp)
jge 0x8b2a
movl -0x24(%rbp), %eax
addl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
setl %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x8b33
jmp 0x8b85
movq -0x8(%rbp), %rdi
movl -0x28(%rbp), %ecx
movl -0x2c(%rbp), %eax
movl $0x2, %esi
cltd
idivl %esi
movl %eax, %esi
leaq 0x4080(%rip), %rdx      # 0xcbce
leaq 0x42ee(%rip), %rax      # 0xce43
cmpl %esi, %ecx
cmoveq %rax, %rdx
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %ecx
leaq 0x389b(%rip), %rsi      # 0xc40e
movb $0x0, %al
callq 0x32c0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x8b0e
movq -0x8(%rbp), %rsi
movl $0xa, %edi
callq 0x33a0
movl -0x2c(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x8a25
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ctSkennerton[P]fxtract/util/msutil.c
// Function: memfind
char const *
memfind(char const *tgt, int tgtlen, char const *pat, int patlen)
{
#   define  _   "\n"
    asm("cld");
    ++pat;
    if (patlen--) asm(
        _"0:repne scasb"
        _"  jne     8f"
        _"  movl    %%ecx, %%edx"
        _"  movl    %%edi, %%ebx"
        _"  movl    %[pat], %%esi"
        _"  movl    %[len], %%ecx"
        _"  repe cmpsb"
        _"  je	    9f"
        _"  movl    %%edx, %%ecx"
        _"  movl    %%ebx, %%edi"
        _"  jmp	    0b"
        _"8:movl    $1,%%ebx"
        _"9:leal    -1(%%ebx), %%eax"
        :     "=a" (tgt)
        :      "a" (pat[-1]),
               "c" (tgtlen - patlen),
               "D" (tgt),
          [pat]"m" (pat),
          [len]"m" (patlen));

    return  tgt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cld
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x8c15
movq -0x18(%rbp), %rax
movb -0x1(%rax), %al
movl -0xc(%rbp), %ecx
subl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rdi
repne  scasb %es:(%rdi), %al
jne 0x8c08
movl %ecx, %edx
movl %edi, %ebx
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %ecx
rep  cmpsb %es:(%rdi), (%rsi)
je 0x8c0d
movl %edx, %ecx
movl %ebx, %edi
jmp 0x8bf0
movl $0x1, %ebx
leal -0x1(%ebx), %eax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: ctSkennerton[P]fxtract/util/msutil.c
// Function: popenf
FILE*
popenf(char const *type, char const *fmt, ...)
{
    char	*cmd;
    va_list	vargs;
    va_start(vargs, fmt);
    int junk = vasprintf(&cmd, fmt, vargs); (void)junk;
    va_end(vargs);
    FILE        *ret = popen(cmd, type);
    free(cmd);
    return  ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x8c5b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x31a0
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3090
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3240
movq -0x40(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x8600
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8600
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x8d24
cmpl $0x0, -0x2c(%rbp)
je 0x8d2f
movl -0x28(%rbp), %eax
subl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x8d83
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl %eax, %edi
movq -0x18(%rbp), %rax
movl %eax, %esi
callq 0x8d90
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movslq %eax, %rdx
callq 0x30e0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x8d70
movl -0x24(%rbp), %eax
movl %eax, -0x44(%rbp)
jmp 0x8d7d
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
subl %ecx, %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8600
cmpl $0x0, %eax
je 0x8dec
movq $0x0, -0x8(%rbp)
jmp 0x8e26
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x3270
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x3160
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x8fdf
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0x30c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8f1f
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x8ef1
movslq -0x28(%rbp), %rdi
shlq $0x4, %rdi
callq 0x3270
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rdi, (%rax)
movsbl -0x9(%rbp), %esi
callq 0x30c0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8fb2
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq (%rax), %rax
subq %rax, %rcx
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x8f3f
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x30d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x8fef
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x19(%rbp)
jbe 0x93ef
callq 0x31e0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl -0x1(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x93f8
jmp 0x9406
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x93bb
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
callq 0x31e0
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x943b
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x940d
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ctSkennerton[P]fxtract/util/msutil.c
// Function: systemf
int
systemf(char const *fmt, ...)
{
    char	*cmd;
    va_list	vargs;
    va_start(vargs, fmt);
    int ret = vasprintf(&cmd, fmt, vargs);
    va_end(vargs);
    ret = system(cmd);
    free(cmd);
    return  ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x948b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rsi, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x8, -0x30(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x31a0
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3180
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3240
movl -0x34(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jl 0xa394
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
je 0xa36f
movl $0x1, -0x4(%rbp)
jmp 0xa404
movslq -0x1c(%rbp), %rax
subq $0x4, %rax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0xa34f
cmpl $0x2, -0x1c(%rbp)
jl 0xa3d8
movq -0x18(%rbp), %rax
movswl (%rax), %eax
movq -0x10(%rbp), %rcx
movswl (%rcx), %ecx
cmpl %ecx, %eax
je 0xa3b5
movl $0x1, -0x4(%rbp)
jmp 0xa404
movslq -0x1c(%rbp), %rax
subq $0x2, %rax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
je 0xa3f9
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30d0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0xa43f
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa4c2
cmpl $0x1, -0x1c(%rbp)
jne 0xa45b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movsbl (%rax), %esi
callq 0x30c0
movq %rax, -0x8(%rbp)
jmp 0xa4c2
jmp 0xa45d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa4d0
movq %rax, %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x1d(%rbp)
je 0xa4a3
movq -0x10(%rbp), %rdi
addq $0x2, %rdi
movq -0x18(%rbp), %rsi
addq $0x2, %rsi
movl -0x1c(%rbp), %eax
subl $0x2, %eax
movslq %eax, %rdx
callq 0x30e0
cmpl $0x0, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0xa4ac
jmp 0xa4ba
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xa45d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30d0
movl %eax, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x3060
movl %eax, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jle 0xa963
jmp 0xa8e4
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x30c0
movq %rax, %rcx
movq %rcx, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x1d(%rbp)
je 0xa92a
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x30e0
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
setl %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0xa933
jmp 0xa961
jmp 0xa935
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xa945
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0xa94e
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xa8e4
jmp 0xa9bc
jmp 0xa965
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x30c0
movq %rax, %rcx
movq %rcx, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x29(%rbp)
je 0xa9a1
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x30e0
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xa9aa
jmp 0xa9ba
jmp 0xa9ac
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xa965
jmp 0xa9bc
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
nopl (%rax,%rax)
// File: ctSkennerton[P]fxtract/util/tap.c
// Function: my_vasprintf
static int
my_vasprintf(char **strp, const char *fmt, va_list ap)
{
    char buffer[1024];
    int  ret;

    ret = vsnprintf(buffer, sizeof(buffer), fmt, ap);

    if ((*strp = malloc(ret + 1)) == NULL) {
        return -1;
    }

    strncpy(*strp, buffer, ret + 1);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x420(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x400, %esi            # imm = 0x400
callq 0x3130
movl %eax, -0x424(%rbp)
movl -0x424(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x3270
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xb10d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb135
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq -0x420(%rbp), %rsi
movl -0x424(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x3100
movl -0x424(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x55e9(%rip)      # 0x107ec
jne 0xb241
movq -0x8(%rbp), %rax
movq %rax, 0x55b0(%rip)      # 0x107c0
callq 0x32e0
movl %eax, 0x55d5(%rip)      # 0x107f0
leaq 0x6e(%rip), %rdi        # 0xb290
callq 0xbae0
movq 0x5592(%rip), %rdi      # 0x107c0
xorl %eax, %eax
movl %eax, %esi
callq 0x32b0
movl $0x1, 0x55ab(%rip)      # 0x107ec
movl 0x55a1(%rip), %eax      # 0x107e8
andl $0x2, %eax
cmpl $0x0, %eax
je 0xb27f
movl $0x2, %edi
leaq 0x1c5(%rip), %rsi       # 0xb420
callq 0x3230
movq %rax, 0x55a9(%rip)      # 0x10810
movl $0xf, %edi
leaq 0x1ad(%rip), %rsi       # 0xb420
callq 0x3230
movq %rax, 0x55f9(%rip)      # 0x10878
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %esi
leaq 0x1988(%rip), %rdi      # 0xcdbd
movb $0x0, %al
callq 0xb6d0
movslq -0x4(%rbp), %rcx
leaq 0x53b9(%rip), %rax      # 0x10800
cmpq $0x0, (%rax,%rcx,8)
jne 0xb466
leaq 0x1986(%rip), %rdi      # 0xcddb
movb $0x0, %al
callq 0xb6d0
movl $0x1, %edi
callq 0x3250
movslq -0x4(%rbp), %rcx
movl $0x1, %edx
leaq 0x538a(%rip), %rax      # 0x10800
cmpq %rdx, (%rax,%rcx,8)
jne 0xb48c
leaq 0x1984(%rip), %rdi      # 0xce07
movb $0x0, %al
callq 0xb6d0
jmp 0xb4b5
movslq -0x4(%rbp), %rcx
leaq 0x5369(%rip), %rax      # 0x10800
movq (%rax,%rcx,8), %rsi
leaq 0x1978(%rip), %rdi      # 0xce1a
movb $0x0, %al
callq 0xb6d0
movq 0x5350(%rip), %rax      # 0x10800
movl -0x4(%rbp), %edi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ctSkennerton[P]fxtract/util/tap.c
// Function: plan_no_plan
void
plan_no_plan(void)
{

    LOCK;

    tap_init(stdout);

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

    have_plan = 1;
    no_plan = 1;

    UNLOCK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x4af5(%rip), %rax      # 0xffc0
movq (%rax), %rdi
callq 0xb1f0
cmpl $0x0, 0x552e(%rip)      # 0x10a08
je 0xb508
movq 0x4af5(%rip), %rax      # 0xffd8
movq (%rax), %rdi
leaq 0x16c8(%rip), %rsi      # 0xcbb5
movb $0x0, %al
callq 0x32c0
movl $0x1, 0x550e(%rip)      # 0x10a0c
movl $0xff, %edi
callq 0x3250
movl $0x1, 0x54f6(%rip)      # 0x10a08
movl $0x1, 0x54f4(%rip)      # 0x10a10
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x4a8d(%rip), %rax      # 0xffc0
movq (%rax), %rdi
callq 0xb1f0
movl $0x1, 0x54cf(%rip)      # 0x10a14
movq 0x5274(%rip), %rdi      # 0x107c0
leaq 0x167c(%rip), %rsi      # 0xcbcf
movb $0x0, %al
callq 0x32c0
cmpq $0x0, -0x8(%rbp)
je 0xb57a
movq 0x5258(%rip), %rdi      # 0x107c0
movq -0x8(%rbp), %rdx
leaq 0x1661(%rip), %rsi      # 0xcbd4
movb $0x0, %al
callq 0x32c0
movq 0x523f(%rip), %rdi      # 0x107c0
leaq 0x1645(%rip), %rsi      # 0xcbcd
movb $0x0, %al
callq 0x32c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ctSkennerton[P]fxtract/util/tap.c
// Function: tap_plan
void
tap_plan(unsigned tests, unsigned flags, FILE * output)
{
    LOCK;

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

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

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

    have_plan = 1;
    _expected_tests(tests);

    UNLOCK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, 0x522d(%rip)      # 0x107e8
cmpq $0x0, -0x10(%rbp)
je 0xb5cc
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xb5da
movq 0x49ed(%rip), %rax      # 0xffc0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb1f0
cmpl $0x0, 0x541e(%rip)      # 0x10a08
je 0xb618
movq 0x49e5(%rip), %rax      # 0xffd8
movq (%rax), %rdi
leaq 0x15b8(%rip), %rsi      # 0xcbb5
movb $0x0, %al
callq 0x32c0
movl $0x1, 0x53fe(%rip)      # 0x10a0c
movl $0xff, %edi
callq 0x3250
cmpl $0x0, -0x4(%rbp)
jne 0xb64a
movq 0x49b3(%rip), %rax      # 0xffd8
movq (%rax), %rdi
leaq 0x15b0(%rip), %rsi      # 0xcbdf
movb $0x0, %al
callq 0x32c0
movl $0x1, 0x53cc(%rip)      # 0x10a0c
movl $0xff, %edi
callq 0x3250
movl $0x1, 0x53b4(%rip)      # 0x10a08
movl -0x4(%rbp), %edi
callq 0xb670
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x4839(%rip), %rax      # 0xffc0
movq (%rax), %rdi
callq 0xb1f0
movq 0x502a(%rip), %rsi      # 0x107c0
leaq 0x16a5(%rip), %rdi      # 0xce42
callq 0x3210
movq 0x5017(%rip), %rdi      # 0x107c0
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x3280
movl %eax, -0x14(%rbp)
movq 0x5000(%rip), %rsi      # 0x107c0
leaq 0x1406(%rip), %rdi      # 0xcbcd
callq 0x3210
movl -0x14(%rbp), %eax
addl $0x3, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0xb81b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xb0b0
cmpl $0x0, %eax
jge 0xb880
movq $0x0, -0x38(%rbp)
leaq -0x30(%rbp), %rax
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x4(%rbp)
cmpl $0x0, %eax
jbe 0xb908
movl 0x4f2e(%rip), %eax      # 0x107c8
addl $0x1, %eax
movl %eax, 0x4f25(%rip)      # 0x107c8
movq 0x4f16(%rip), %rax      # 0x107c0
movq %rax, -0x100(%rbp)
movl 0x4f11(%rip), %eax      # 0x107c8
movl %eax, -0xf4(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xb8d1
movq -0x38(%rbp), %rax
movq %rax, -0x108(%rbp)
jmp 0xb8e1
leaq 0x1350(%rip), %rax      # 0xcc28
movq %rax, -0x108(%rbp)
jmp 0xb8e1
movl -0xf4(%rbp), %edx
movq -0x100(%rbp), %rdi
movq -0x108(%rbp), %rcx
leaq 0x131b(%rip), %rsi      # 0xcc17
movb $0x0, %al
callq 0x32c0
jmp 0xb884
movq -0x38(%rbp), %rdi
callq 0x3240
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0xb955
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq 0x4e31(%rip), %rdi      # 0x107e0
callq 0xb0b0
cmpl $0x0, %eax
jge 0xb9c4
movq $0x0, 0x4e1c(%rip) # 0x107e0
movl $0x1, 0x4e0a(%rip)      # 0x107d8
addq $0xd0, %rsp
popq %rbp
retq
nopw (%rax,%rax)