LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.c
// Function: gdc_circular_queue_alloc
void*
gdc_circular_queue_alloc(gdc_circular_queue *q, size_t len)
{
	assert(len > 0);
	assert(len < gdc_circular_queue_capacity(q));
	
	size_t rp = atomic_load_explicit(&q->rpos, memory_order_relaxed);
	size_t wp = atomic_load_explicit(&q->wpos, memory_order_relaxed);
	
	if (len > space(q, rp, wp))
	{
		return NULL;
	}
	
	char* d = gdc_circular_queue_data(q);
	char* p = &d[wp];
	return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x44cb6
movq %rdi, %rbx
movq 0x80(%rdi), %rax
cmpq %rsi, %rax
jbe 0x44cd5
movq (%rbx), %rax
movq 0x40(%rbx), %r14
movq 0x80(%rbx), %rcx
movq %r14, %rdx
notq %rdx
addq %rax, %rdx
addq %rcx, %rdx
subq %r14, %rax
cmovbeq %rdx, %rax
cmpq %rcx, %rax
jae 0x44cf4
cmpq %rsi, %rax
jae 0x44c86
xorl %ebx, %ebx
jmp 0x44cab
cmpq $-0x1, 0x1d8d2(%rip)    # 0x62560
jne 0x44ca1
movl $0x1e, %edi
callq 0xc2c0
movq %rax, 0x1d8bf(%rip)     # 0x62560
addq 0x1d8b8(%rip), %rbx     # 0x62560
addq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x51a3(%rip), %rdi      # 0x49e60
leaq 0x5149(%rip), %rsi      # 0x49e0d
leaq 0x519d(%rip), %rcx      # 0x49e68
movl $0xce, %edx
callq 0xc2d0
leaq 0x51c9(%rip), %rdi      # 0x49ea5
leaq 0x512a(%rip), %rsi      # 0x49e0d
leaq 0x517e(%rip), %rcx      # 0x49e68
movl $0xcf, %edx
callq 0xc2d0
leaq 0x522f(%rip), %rdi      # 0x49f2a
leaq 0x510b(%rip), %rsi      # 0x49e0d
leaq 0x5265(%rip), %rcx      # 0x49f6e
movl $0x12a, %edx            # imm = 0x12A
callq 0xc2d0
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.c
// Function: gdc_circular_queue_commit
void
gdc_circular_queue_commit(gdc_circular_queue *q, size_t len)
{
	assert(len > 0);
	assert(len < gdc_circular_queue_capacity(q));
	assert(len <= gdc_circular_queue_space(q));
	advance_wpos(q, len);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x44d61
movq %rsi, %r14
movq %rdi, %rbx
movq 0x80(%rdi), %rax
cmpq %rsi, %rax
jbe 0x44d80
movq %rbx, %rdi
callq 0x44b31
cmpq %r14, %rax
jb 0x44d9f
movq 0x40(%rbx), %rax
addq %r14, %rax
movq 0x80(%rbx), %rcx
xorl %edx, %edx
divq %rcx
cmpl $0x0, 0x88(%rbx)
movq %rdx, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x50f8(%rip), %rdi      # 0x49e60
leaq 0x509e(%rip), %rsi      # 0x49e0d
leaq 0x5154(%rip), %rcx      # 0x49eca
movl $0xe2, %edx
callq 0xc2d0
leaq 0x511e(%rip), %rdi      # 0x49ea5
leaq 0x507f(%rip), %rsi      # 0x49e0d
leaq 0x5135(%rip), %rcx      # 0x49eca
movl $0xe3, %edx
callq 0xc2d0
leaq 0x5161(%rip), %rdi      # 0x49f07
leaq 0x5060(%rip), %rsi      # 0x49e0d
leaq 0x5116(%rip), %rcx      # 0x49eca
movl $0xe4, %edx
callq 0xc2d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.c
// Function: gdc_circular_queue_create_shared
int
gdc_circular_queue_create_shared(
	const char* name,
	size_t capacity,
	int sync,
	int (*mdinit)(gdc_circular_queue*, void*),
	void* md_context)
{
	// Unlink any old shared memory object with the same name.
	int status = shm_unlink(name);
	if (status == -1 && errno != ENOENT)
	{
		return -1;
	}
	
	// Create a new shared memory object.
	int fd = shm_open(name, O_RDWR | O_CREAT | O_EXCL, S_IRWXU);
	if (fd == -1)
	{
		shm_unlink(name);
		return -1;
	}
	
	size_t len = gdc_circular_queue_footprint(capacity) + capacity;
	status = ftruncate(fd, len);
	if (status != 0)
	{
		close(fd);
		shm_unlink(name);
		return -1;
	}
	
	void *p = mmap(
		NULL,
		len,
		PROT_READ | PROT_WRITE,
		MAP_SHARED,
		fd,
		0);
	if (p == MAP_FAILED)
	{
		shm_unlink(name);
		close(fd);
		return -1;
	}
	
	gdc_circular_queue* q = p;
	status = gdc_circular_queue_init(q, capacity, sync, mdinit, md_context);
	
	if (status == -1)
	{
		shm_unlink(name);
		close(fd);
		return status;
	}
	
	if (munmap(p, len) != 0)
	{
		shm_unlink(name);
		close(fd);
		return -1;
	}
	
	if (close(fd) != 0)
	{
		shm_unlink(name);
		return -1;
	}
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, %r14
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %rbx
callq 0xc890
cmpl $-0x1, %eax
jne 0x44dfd
callq 0xc050
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x2, (%rcx)
jne 0x44eb0
movq %rbx, %rdi
movl $0xc2, %esi
movl $0x1c0, %edx            # imm = 0x1C0
callq 0xc780
cmpl $-0x1, %eax
je 0x44e3e
movl %eax, %ebp
movq %r14, 0x10(%rsp)
movq %r13, %rdi
callq 0x44ed2
movq %rax, %r14
addq %r13, %r14
movl %ebp, %edi
movq %r14, %rsi
callq 0xc600
testl %eax, %eax
je 0x44e48
movl %ebp, %edi
callq 0xc8e0
movq %rbx, %rdi
callq 0xc890
jmp 0x44eab
movq %r15, 0x8(%rsp)
xorl %edi, %edi
movq %r14, %rsi
movl $0x3, %edx
movl $0x1, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0xc830
cmpq $-0x1, %rax
je 0x44e9c
movq %rax, %r15
movq %rax, %rdi
movq %r13, %rsi
movl %r12d, %edx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x44a6c
cmpl $-0x1, %eax
je 0x44e9c
movq %r15, %rdi
movq %r14, %rsi
callq 0xc250
testl %eax, %eax
je 0x44ebf
movq %rbx, %rdi
callq 0xc890
movl %ebp, %edi
callq 0xc8e0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
callq 0xc8e0
testl %eax, %eax
jne 0x44e3e
xorl %eax, %eax
jmp 0x44eb0
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.c
// Function: gdc_circular_queue_footprint
static size_t
gdc_circular_queue_footprint(size_t capacity)
{
	long page_size = sysconf(_SC_PAGESIZE);
	if (page_size == -1)
	{
		return 0;
	}
	assert(page_size > 0);
	
	if (capacity == 0)
	{
		return page_size;
	}
	
	// Calculate the smallest multiple of page size that is >= page size + capacity.
	// The first page is for struct gdc_circular_queue. The other pages are for data.
	// Examples:
	// capacity == 0 => footprint = page_size.
	// capacity == 1 => footprint = page_size.
	// capacity == page_size => footprint = page_size.
	// capacity == page_size + 1 => footprint = 2 * page_size.
	long footprint = page_size + (((capacity - 1) / page_size) + 1) * page_size;
	return footprint;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1e, %edi
callq 0xc2c0
cmpq $-0x1, %rax
je 0x44f08
movq %rax, %rcx
testq %rax, %rax
jle 0x44f0f
testq %rbx, %rbx
je 0x44f0a
decq %rbx
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
addq $0x2, %rax
imulq %rax, %rcx
jmp 0x44f0a
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
retq
leaq 0x50da(%rip), %rdi      # 0x49ff0
leaq 0x50e1(%rip), %rsi      # 0x49ffe
leaq 0x513b(%rip), %rcx      # 0x4a05f
movl $0x30, %edx
callq 0xc2d0
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.c
// Function: gdc_circular_queue_create_private
gdc_circular_queue*
gdc_circular_queue_create_private(
	size_t capacity,
	int sync,
	int (*mdinit)(gdc_circular_queue*, void*),
	void* md_context)
{
	static atomic_int seq;
	int unique = atomic_fetch_add_explicit(&seq, 1, memory_order_relaxed);
	pid_t pid = getpid();
	char tmp_name[32];
	sprintf(tmp_name, "/.gdc.%d.%d", pid, unique);
	
	if (gdc_circular_queue_create_shared(tmp_name, capacity, sync, mdinit, md_context) == -1)
	{
		return NULL;
	}
	
	gdc_circular_queue *q = gdc_circular_queue_map_shared(tmp_name);
	gdc_circular_queue_delete_shared(tmp_name);
	return q;
	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
movl $0x1, %r13d
lock
xaddl %r13d, 0x1d84f(%rip)    # 0x627ac
callq 0xc670
leaq 0x507b(%rip), %rsi      # 0x49fe4
xorl %ebx, %ebx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl %eax, %edx
movl %r13d, %ecx
xorl %eax, %eax
callq 0xc0a0
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r15, %rcx
movq 0x8(%rsp), %r8
callq 0x44dc0
cmpl $-0x1, %eax
je 0x44fb1
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x44fc3
movq %rax, %rbx
movq %r14, %rdi
callq 0xc890
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.c
// Function: gdc_circular_queue_unmap_shared
int
gdc_circular_queue_unmap_shared(gdc_circular_queue *q)
{
	if (q != NULL)
	{
		size_t capacity = gdc_circular_queue_capacity(q);
		size_t footprint = gdc_circular_queue_footprint(capacity);
		return munmap(q, footprint + capacity);
	}
	
	return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x45188
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x44ad8
movq %rax, %r14
movq %rax, %rdi
callq 0x44ed2
addq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc250
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/sotrteacher[P]1MM1INTRO/20190820_1MM1_INTRO/porvalor_porreferencia.c
// Function: intercambiar1
void intercambiar1(float *A,float *B)
{
  float tmp;
  tmp=*A;
  *A=*B;
  *B=tmp;
  mostrar1(*A,*B);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movss (%rdi), %xmm0
movss (%rsi), %xmm1
movss %xmm1, (%rdi)
movss %xmm0, (%rsi)
leaq 0xe2c(%rip), %r15       # 0x2020
leaq 0xe36(%rip), %rsi       # 0x2031
movq %r15, %rdi
xorl %eax, %eax
callq 0x1050
xorps %xmm0, %xmm0
cvtss2sd (%r14), %xmm0
leaq 0xe11(%rip), %r14       # 0x2025
movq %r14, %rdi
movb $0x1, %al
callq 0x1050
leaq 0xe0f(%rip), %rsi       # 0x2034
movq %r15, %rdi
xorl %eax, %eax
callq 0x1050
xorps %xmm0, %xmm0
cvtss2sd (%rbx), %xmm0
movq %r14, %rdi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1050
// File: /workspace/github_cpp_makefile_star2_O1/sotrteacher[P]1MM1INTRO/20190820_1MM1_INTRO/porvalor_porreferencia.c
// Function: main
int main(int argc,char *argv[])
{
  float x,y;
  x=1.4142;
  y=3.1416;
  printf("Version: ");
  VERSION(X,Y,Z);
  printf("\nmain:\n");
  mostrar2(float,x,y);
  printf("\n/***********************************************/\n");
  printf("\n");
  printf("intercambiar:\n");
  intercambiar(x,y);/*paso de argumentos por valor*/
  printf("\nmain:\n");
  mostrar2(float,x,y);
  printf("\n/***********************************************/\n");
  printf("\n");
  printf("intercambiar1:\n");
  intercambiar1(&x,&y);/*paso de argumentos por referencia*/
  printf("\nmain:\n");
  mostrar2(float,x,y);
  printf("\n/***********************************************/\n");
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq -0x30(%rbp), %rax
movl $0x3fb50481, (%rax)     # imm = 0x3FB50481
leaq -0x2c(%rbp), %rax
movl $0x40490ff9, (%rax)     # imm = 0x40490FF9
leaq 0xdc4(%rip), %rdi       # 0x2037
xorl %eax, %eax
callq 0x1050
leaq 0xdc0(%rip), %rdi       # 0x2041
leaq 0x2db8(%rip), %rsi      # 0x4040
leaq 0x2db6(%rip), %rdx      # 0x4045
leaq 0x2db2(%rip), %rcx      # 0x4048
xorl %eax, %eax
callq 0x1050
leaq 0xdee(%rip), %rdi       # 0x2092
callq 0x1040
leaq 0xd70(%rip), %r15       # 0x2020
leaq 0xd93(%rip), %r14       # 0x204a
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1050
leaq 0xd5a(%rip), %r12       # 0x2025
movsd 0xd35(%rip), %xmm0      # 0x2008
movq %r12, %rdi
movb $0x1, %al
callq 0x1050
leaq 0xd68(%rip), %r13       # 0x204c
movq %r15, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x1050
movsd 0xd17(%rip), %xmm0      # 0x2010
movq %r12, %rdi
movb $0x1, %al
callq 0x1050
leaq 0xd8f(%rip), %rbx       # 0x2099
movq %rbx, %rdi
callq 0x1040
movl $0xa, %edi
callq 0x1030
leaq 0xd52(%rip), %rdi       # 0x2075
callq 0x1040
movss 0xce8(%rip), %xmm0      # 0x2018
movss 0xce4(%rip), %xmm1      # 0x201c
callq 0x115c
leaq 0xd4e(%rip), %rdi       # 0x2092
callq 0x1040
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1050
movq %r12, %rdi
movsd 0xca7(%rip), %xmm0      # 0x2008
movb $0x1, %al
callq 0x1050
movq %r15, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x1050
movq %r12, %rdi
movsd 0xc90(%rip), %xmm0      # 0x2010
movb $0x1, %al
callq 0x1050
movq %rbx, %rdi
callq 0x1040
movl $0xa, %edi
callq 0x1030
leaq 0xce3(%rip), %rdi       # 0x2083
callq 0x1040
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
leaq -0x2c(%rbp), %r14
movq %r14, %rsi
callq 0x11cd
leaq 0xcd3(%rip), %rdi       # 0x2092
callq 0x1040
movq %r15, %rdi
leaq 0xc7c(%rip), %rsi       # 0x204a
xorl %eax, %eax
callq 0x1050
xorps %xmm0, %xmm0
cvtss2sd (%rbx), %xmm0
movq %r12, %rdi
movb $0x1, %al
callq 0x1050
movq %r15, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x1050
xorps %xmm0, %xmm0
cvtss2sd (%r14), %xmm0
movq %r12, %rdi
movb $0x1, %al
callq 0x1050
leaq 0xc8d(%rip), %rdi       # 0x2099
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x5cc2
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x5cc3
movq 0x8(%rbx), %rdi
callq 0x3250
movq %rbx, %rdi
popq %rbx
jmp 0x3250
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
jne 0x5d04
jmp 0x5d0b
testq %rbx, %rbx
sete %cl
testl %eax, %eax
sete %dl
orb %cl, %dl
je 0x5ce7
xorl %edi, %edi
jmp 0x5cfb
cltq
decq %rax
movl %eax, 0x4(%rbx)
movslq 0x10(%rbx), %rdi
imulq %rax, %rdi
addq 0x8(%rbx), %rdi
movq 0x20(%rbx), %rsi
xorl %eax, %eax
callq *0x18(%rbx)
movl 0x4(%rbx), %eax
cmpl %ebp, %eax
jg 0x5cd4
movq 0x8(%rbx), %rdi
movslq 0x10(%rbx), %rax
movl %ebp, (%rbx)
movslq %ebp, %rsi
imulq %rax, %rsi
callq 0x3340
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x5de1
movl 0x4(%rbx), %r15d
jmp 0x5de4
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x30d0
addl %r15d, %eax
incl %eax
cmpl %eax, (%rbx)
jge 0x5e0f
movq 0x8(%rbx), %rdi
movslq 0x10(%rbx), %rcx
movl %eax, (%rbx)
movslq %eax, %rsi
imulq %rcx, %rsi
callq 0x3340
movq %rax, 0x8(%rbx)
movslq %r15d, %rdi
addq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x31b0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movl $0x28, %esi
movq %r15, %rdx
callq 0x3210
movq %rax, %r14
subq %rbx, %r14
testq %rax, %rax
cmoveq %r15, %r14
movq %rbx, %rdi
movl $0x3c, %esi
movq %r14, %rdx
callq 0x3210
testq %rax, %rax
je 0x5ec3
movq %rax, %r15
leaq (%rbx,%r14), %rdx
subq %rax, %rdx
movq %rax, %rdi
movl $0x3e, %esi
callq 0x3210
testq %rax, %rax
je 0x5ec3
movq %r15, %rcx
notq %rcx
addq %rcx, %rax
incq %r15
movq %r15, %rbx
movq %rax, %r14
incq %r14
cmpq $0x1, %r14
je 0x5ee6
callq 0x31f0
movq (%rax), %rax
movsbq -0x2(%rbx,%r14), %rcx
decq %r14
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x5ec6
jmp 0x5ee9
xorl %r14d, %r14d
testq %r14, %r14
je 0x5f0c
callq 0x31f0
movq (%rax), %rax
movsbq (%rbx), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x5f0c
incq %rbx
decq %r14
jne 0x5ef6
xorl %r14d, %r14d
xorl %eax, %eax
testl %r14d, %r14d
cmovneq %rbx, %rax
testq %rbx, %rbx
movslq %r14d, %rdx
cmoveq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x24c1(%rip), %rsi      # 0x83f8
callq 0x3230
testq %rax, %rax
je 0x5f64
movq %rax, %r15
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rcx
callq 0x33c0
movq %rax, %rbx
movq %r15, %rdi
callq 0x31c0
jmp 0x5f66
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
testl %edi, %edi
je 0x5fc8
movl %edi, %eax
shrl $0x10, %eax
xorl %ecx, %ecx
cmpl $0x10000, %edi          # imm = 0x10000
setae %cl
cmovbl %edi, %eax
shll $0x4, %ecx
leal 0x1(%rcx), %edx
movl %eax, %esi
shrl $0x8, %esi
orl $0x9, %ecx
cmpl $0x100, %eax            # imm = 0x100
cmovbl %eax, %esi
cmovbl %edx, %ecx
movl %esi, %edx
shrl $0x4, %edx
leal 0x4(%rcx), %edi
cmpl $0x10, %esi
cmovbl %esi, %edx
cmovbl %ecx, %edi
movl %edx, %ecx
shrl $0x2, %ecx
leal 0x2(%rdi), %eax
cmpl $0x4, %edx
cmovbl %edx, %ecx
cmovbl %edi, %eax
btl $0x1, %ecx
adcl $0x0, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/msutil.c
// Function: cmpxm
int
cmpxm(void const*_src, void const*_dst, int len)
{
    uint8_t const *src = (uint8_t const*)_src;
    uint8_t const *dst = (uint8_t const*)_dst;
    int ret, srcoff = 15 & (intptr_t)src;

    if (srcoff && len > 31) {
        if ((ret = xm_diff(xm_loud(src), xm_loud(dst))))
            return cmp(ret, src, dst);

        src += 16 - srcoff;
        dst += 16 - srcoff;
        len -= 16 - srcoff;
    }

    // A special case for srcoff==dstoff => xm_load(dst)
    // seems to make no difference.
    // Prefetch windows from 128..512 all do about the same.
#   define PRE (512-64)
    for (; len >= 16; src += 16, dst += 16, len -=16) {
        _mm_prefetch(src+PRE, _MM_HINT_NTA);
        _mm_prefetch(dst+PRE, _MM_HINT_NTA);
        if ((ret = xm_diff(xm_load(src), xm_loud(dst))))
            return cmp(ret, src, dst);
    }

    // xm_loud(dst) can actually go beyond valid mem :-(
    ret = xm_diff(xm_loud(src), xm_loud(dst)) & ~(-1 << len);
    return ret ? cmp(ret,  src, dst) : 0;
}

// Assembly:
movl %edi, %eax
andl $0xf, %eax
sete %cl
cmpl $0x20, %edx
setl %r8b
orb %cl, %r8b
jne 0x600d
movdqu (%rdi), %xmm0
movdqu (%rsi), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %ecx
cmpl $0xffff, %ecx           # imm = 0xFFFF
je 0x5ffe
notl %ecx
bsfl %ecx, %eax
jmp 0x607b
movl $0x10, %ecx
subl %eax, %ecx
addq %rcx, %rdi
addq %rcx, %rsi
subl %ecx, %edx
cmpl $0x10, %edx
jl 0x6053
leal 0x10(%rdx), %ecx
xorl %eax, %eax
prefetchnta 0x1c0(%rdi,%rax)
prefetchnta 0x1c0(%rsi,%rax)
movdqu (%rsi,%rax), %xmm0
pcmpeqb (%rdi,%rax), %xmm0
pmovmskb %xmm0, %r8d
cmpl $0xffff, %r8d           # imm = 0xFFFF
jne 0x6086
addq $0x10, %rax
addl $-0x10, %ecx
cmpl $0x1f, %ecx
jg 0x6017
addq %rax, %rsi
addq %rax, %rdi
subl %eax, %edx
movdqu (%rdi), %xmm0
movdqu (%rsi), %xmm1
pcmpeqb %xmm0, %xmm1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %edx, %ecx
shll %cl, %eax
pmovmskb %xmm1, %ecx
xorl $0xffff, %ecx           # imm = 0xFFFF
notl %eax
andl %ecx, %eax
je 0x6083
bsfl %eax, %eax
addq %rax, %rdi
addq %rax, %rsi
jmp 0x6099
xorl %eax, %eax
retq
notl %r8d
bsfl %r8d, %ecx
addq %rax, %rdi
addq %rcx, %rdi
addq %rax, %rsi
addq %rcx, %rsi
movzbl (%rdi), %eax
movzbl (%rsi), %ecx
subl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/msutil.c
// Function: memsame
int memsame(void const*_src, void const*_dst, int len)
{
    uint8_t const *src = (uint8_t const*)_src;
    uint8_t const *dst = (uint8_t const*)_dst;
    int ret, srcoff = 15 & (intptr_t)src;

    if (srcoff && len > 31) {
        if ((ret = xm_diff(xm_loud(src), xm_loud(dst))))
            return src - (uint8_t const*)_src + ffs(ret) - 1;

        src += 16 - srcoff;
        dst += 16 - srcoff;
        len -= 16 - srcoff;
    }

    // A special case for srcoff==dstoff => xm_load(dst)
    //  seems to make no difference.
    // Prefetch windows from 128..512 all do about the same.
#   define PRE (512-64)
    for (; len >= 16; src += 16, dst += 16, len -=16) {
        _mm_prefetch(src+PRE, _MM_HINT_NTA);
        _mm_prefetch(dst+PRE, _MM_HINT_NTA);
        if ((ret = xm_diff(xm_load(src), xm_loud(dst))))
            return src - (uint8_t const*)_src + ffs(ret) - 1;
    }

    if ((ret = xm_diff(xm_loud(src), xm_loud(dst)) & ~(-1 << len)))
        return src - (uint8_t const*)_src + ffs(ret) - 1;
    return 0;
}

// Assembly:
movl %edi, %eax
andl $0xf, %eax
sete %cl
cmpl $0x20, %edx
setl %r8b
orb %cl, %r8b
jne 0x60d4
movdqu (%rdi), %xmm0
movdqu (%rsi), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %ecx
cmpl $0xffff, %ecx           # imm = 0xFFFF
je 0x60d9
notl %ecx
bsfl %ecx, %eax
retq
movq %rdi, %r8
jmp 0x60e9
movl $0x10, %ecx
subl %eax, %ecx
leaq (%rdi,%rcx), %r8
addq %rcx, %rsi
subl %ecx, %edx
cmpl $0x10, %edx
jl 0x612f
movl %edi, %r9d
subl %r8d, %r9d
prefetchnta 0x1c0(%r8)
prefetchnta 0x1c0(%rsi)
movdqu (%rsi), %xmm0
pcmpeqb (%r8), %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jne 0x6162
addq $0x10, %r8
addq $0x10, %rsi
leal -0x10(%rdx), %ecx
addl $-0x10, %r9d
cmpl $0x1f, %edx
movl %ecx, %edx
jg 0x60f4
jmp 0x6131
movl %edx, %ecx
movdqu (%r8), %xmm0
movdqu (%rsi), %xmm1
pcmpeqb %xmm0, %xmm1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
pmovmskb %xmm1, %ecx
xorl $0xffff, %ecx           # imm = 0xFFFF
notl %eax
andl %ecx, %eax
je 0x615f
subl %edi, %r8d
bsfl %eax, %eax
addl %r8d, %eax
retq
xorl %eax, %eax
retq
notl %eax
bsfl %eax, %eax
subl %r9d, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x3150
movl %eax, %ebp
testl %eax, %eax
js 0x61b9
movl %ebp, %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0x33a0
movq %rax, %r14
xorl %edi, %edi
movq %rax, %rsi
movl $0x1, %edx
movl $0x1, %ecx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x3380
movq %rax, %rbx
movl %ebp, %edi
callq 0x33d0
jmp 0x61bc
xorl %r14d, %r14d
testl %ebp, %ebp
sets %al
testq %r14, %r14
sete %cl
cmpq $-0x1, %rbx
sete %dl
orb %cl, %dl
xorl %ecx, %ecx
orb %al, %dl
cmovneq %rcx, %rbx
cmovneq %rcx, %r14
movq %rbx, %rax
movq %r14, %rdx
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/msutil.c
// Function: findbit_0
int
findbit_0(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 ones = {-1, -1};
    uint16_t m = BYTEDIFF(bp, ones);
    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, ones))
        bp += 16, len -= 16, _mm_prefetch(bp+512, _MM_HINT_NTA);
        // Mask off trailing bits (tail of vec)
    if (len < 16) m &= ~(-1 << len);  
    return m ? (off = bsrl(m), 8*(off+bp-vec) + bsrl(bp[off] ^ 0xFF)) : -1;
}

// Assembly:
pushq %rbx
movl %edi, %edx
andl $0xf, %edx
movq %rdi, %r8
andq $-0x10, %r8
pcmpeqd %xmm0, %xmm0
movdqa (%r8), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %r11d
addl %edx, %esi
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
movl %esi, %ecx
shll %cl, %r10d
notl %r11d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x10, %esi
setl %bl
notl %r10d
movl $0xffff, %r9d           # imm = 0xFFFF
cmovgel %r9d, %r10d
movl %edx, %ecx
shrl %cl, %r10d
shll %cl, %r10d
andl %r11d, %r10d
testw %r10w, %r10w
setne %cl
orb %bl, %cl
jne 0x6277
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 0x6272
cmpl $0x1f, %esi
movl %ecx, %esi
jg 0x6244
notl %r10d
jmp 0x6279
movl %esi, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
cmpl $0x10, %ecx
notl %edx
cmovll %edx, %r9d
andw %r10w, %r9w
je 0x62ae
movzwl %r9w, %eax
bsrl %eax, %eax
cltq
leaq (%r8,%rax), %rcx
subl %edi, %ecx
movzbl (%r8,%rax), %eax
xorl $0xff, %eax
bsrl %eax, %eax
leal (%rax,%rcx,8), %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movl %edi, %edx
andl $0xf, %edx
movq %rdi, %r8
andq $-0x10, %r8
pxor %xmm0, %xmm0
movdqa (%r8), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %r11d
addl %edx, %esi
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
movl %esi, %ecx
shll %cl, %r10d
notl %r11d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x10, %esi
setl %bl
notl %r10d
movl $0xffff, %r9d           # imm = 0xFFFF
cmovgel %r9d, %r10d
movl %edx, %ecx
shrl %cl, %r10d
shll %cl, %r10d
andl %r11d, %r10d
testw %r10w, %r10w
setne %cl
orb %bl, %cl
jne 0x6340
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 0x633b
cmpl $0x1f, %esi
movl %ecx, %esi
jg 0x630d
notl %r10d
jmp 0x6342
movl %esi, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
cmpl $0x10, %ecx
notl %edx
cmovll %edx, %r9d
andw %r10w, %r9w
je 0x6372
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
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rdx, %rax
orq %rsi, %rax
je 0x63cc
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rax
leaq (%rdx,%rax), %rsi
incq %rsi
callq 0x3340
movq %rax, (%r14)
movq 0x8(%r14), %r12
leaq (%rax,%r12), %rdi
movb $0x0, (%rbx,%rdi)
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3160
addq %rbx, %r12
movq %r12, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x640d
callq 0x31f0
movq (%rax), %rcx
movsbq -0x1(%rbx,%r14), %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
je 0x640d
movb $0x0, -0x1(%rbx,%r14)
decq %r14
jne 0x63ef
xorl %r14d, %r14d
movq %rbx, %rax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x647e
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 0x64ba
callq 0x6527
movq 0x4b29(%rip), %rcx      # 0xafd8
movq (%rcx), %rsi
movq %rax, %rdi
callq 0x3220
movq 0x4b17(%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 0x6510
movq (%r15), %rbx
callq 0x3040
movslq (%rax), %rdi
leaq 0x4d10(%rip), %rax      # 0xb200
movq (%rax,%rdi,8), %r14
callq 0x30a0
leaq 0x1efa(%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_O1/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 %rbx
subq $0x3f0, %rsp            # imm = 0x3F0
cmpq $0x0, 0x5271(%rip)      # 0xb7a8
jne 0x65a2
callq 0x32f0
leaq 0x1ebc(%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
jne 0x65b2
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, 0x5206(%rip)      # 0xb7a8
movq 0x51ff(%rip), %rax      # 0xb7a8
addq $0x3f0, %rsp            # imm = 0x3F0
popq %rbx
retq
xorl %eax, %eax
jmp 0x65a9
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x6616
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)
leaq 0x10(%rsp), %rdx
movq %rdi, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x31a0
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x3230
movq %rax, %rbx
movq (%r14), %rdi
callq 0x3250
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6760
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 0x66c1
movl $0x20, %edi
movq %r15, %rsi
callq 0x33b0
movl $0x20, %edi
cmpq %r13, %rbp
jae 0x66e6
callq 0x31f0
movq (%rax), %rcx
movzbl (%r14,%rbp), %eax
testb $0x40, 0x1(%rcx,%rax,2)
movl $0x2e, %edi
je 0x66e6
movl %eax, %edi
movq %r15, %rsi
callq 0x33b0
incq %rbp
decq %rbx
jne 0x66ae
movl $0x7c, %edi
movq %r15, %rsi
callq 0x33b0
movl $0x20, %ebx
movq %r12, %rbp
cmpq %r13, %rbp
jae 0x6744
cmpq $0x10, %rbx
leaq 0x24b3(%rip), %rdx      # 0x8bce
leaq 0x2721(%rip), %rax      # 0x8e43
cmoveq %rax, %rdx
movzbl (%r14,%rbp), %ecx
movq %r15, %rdi
leaq 0x1cd9(%rip), %rsi      # 0x840e
xorl %eax, %eax
callq 0x32d0
incq %rbp
decq %rbx
jne 0x670b
movl $0xa, %edi
movq %r15, %rsi
callq 0x33b0
addq $0x20, %r12
cmpl 0x4(%rsp), %r12d
jl 0x6699
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rdx, -0x8(%rsp)
movl %ecx, -0xc(%rsp)
cld
movq -0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
movq %rcx, -0x8(%rsp)
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, -0xc(%rsp)
jb 0x67c0
movb (%rax), %al
subl %ecx, %esi
movl %esi, %ecx
repne  scasb %es:(%rdi), %al
jne 0x67b4
movl %ecx, %edx
movl %edi, %ebx
movl -0x8(%rsp), %esi
movl -0xc(%rsp), %ecx
rep  cmpsb %es:(%rdi), (%rsi)
je 0x67b9
movl %edx, %ecx
movl %ebx, %edi
jmp 0x679a
movl $0x1, %ebx
leal -0x1(%ebx), %eax
movq %rax, %rdi
movq %rdi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x68a6
movb %r8b, %bl
movb %r9b, %al
subl %eax, %ebx
jmp 0x68c0
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_O1/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 0x68f8
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_O1/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
movq %rdx, %rbx
cmpb $0x0, (%rdi)
je 0x69bf
movq %rdi, %r14
movsbl %sil, %ebp
movl %ebp, %esi
callq 0x30c0
movl $0x1, %r12d
testq %rax, %rax
je 0x6966
incl %r12d
incq %rax
movq %rax, %rdi
movl %ebp, %esi
callq 0x30c0
jmp 0x694f
movl %r12d, %edi
shlq $0x4, %rdi
callq 0x3280
movq %rax, %r15
movq %r14, (%rax)
movq %r14, %rdi
movl %ebp, %esi
callq 0x30c0
movq %r15, %r13
testq %rax, %rax
je 0x69b1
movq %rax, %rcx
subq %r14, %rcx
movq %rcx, 0x8(%r13)
movb $0x0, (%rax)
movq %rax, %r14
incq %r14
movq %r14, 0x10(%r13)
addq $0x10, %r13
movq %r14, %rdi
movl %ebp, %esi
callq 0x30c0
jmp 0x6985
movq %r14, %rdi
callq 0x30d0
movq %rax, 0x8(%r13)
jmp 0x69c5
xorl %r12d, %r12d
xorl %r15d, %r15d
testq %rbx, %rbx
je 0x69cd
movl %r12d, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x6a70
movq %rdi, %r14
cmpb $0x0, (%rdi)
je 0x6a70
leaq 0x19c0(%rip), %rsi      # 0x8416
movq %r14, %rdi
callq 0x32b0
testl %eax, %eax
je 0x6a70
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x3150
movl %eax, %ebx
testl %ebx, %ebx
js 0x6a84
leaq 0x8(%rsp), %rsi
movl %ebx, %edi
callq 0x3350
testl %eax, %eax
je 0x6ab8
xorl %r14d, %r14d
testl %ebx, %ebx
js 0x6a92
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 0x6af2
movl 0x38(%rsp), %r15d
testq %r15, %r15
je 0x6b6e
leal 0x1(%r15), %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x3140
movq %rax, %r14
movslq %r15d, %r15
jmp 0x6b74
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 0x6b8e
movl $0x1000, %r13d          # imm = 0x1000
xorl %r15d, %r15d
movl %r13d, %eax
subl %r15d, %eax
cmpl %r12d, %eax
jne 0x6b49
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 0x6b1f
jmp 0x6b91
xorl %r14d, %r14d
xorl %r15d, %r15d
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x32e0
movl %eax, %eax
cmpq %rax, %r15
jne 0x6a87
jmp 0x6bae
xorl %r15d, %r15d
testl %r12d, %r12d
js 0x6ba5
leaq 0x1(%r15), %rsi
movq %r14, %rdi
callq 0x3340
movq %rax, %r14
testl %r12d, %r12d
js 0x6a87
movl %ebx, %edi
callq 0x33d0
movb $0x0, (%r14,%r15)
jmp 0x6aa0
// File: /workspace/github_cpp_makefile_star2_O1/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
addq %rbx, %rax
movq %rax, %r14
cmpq %rbx, %rax
jbe 0x6bee
callq 0x31f0
movq (%rax), %rcx
leaq -0x1(%r14), %rax
movsbq -0x1(%r14), %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0x6bce
movb $0x0, (%r14)
callq 0x31f0
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x6bfd
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %r10
leaq 0x30(%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 0x6c7a
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)
leaq 0x10(%rsp), %rdx
movq %rdi, 0x10(%rdx)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r10, %rsi
callq 0x31a0
movq (%rbx), %rdi
callq 0x3180
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x3250
movl %ebp, %eax
addq $0xe8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6d8e
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 0x6dae
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 0x6da0
bsfl %edx, %eax
jmp 0x6e13
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3360
testl %eax, %eax
jne 0x6e0c
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 0x6de9
movdqa %xmm2, %xmm4
pcmpeqb %xmm0, %xmm4
pcmpeqb %xmm1, %xmm2
por %xmm4, %xmm2
pmovmskb %xmm2, %eax
testl %eax, %eax
jne 0x6e10
movdqa 0x10(%rbx), %xmm2
addq $0x10, %rbx
jmp 0x6db6
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 0x6e0c
bsfl %eax, %eax
jmp 0x6e13
xorl %ebx, %ebx
jmp 0x6e16
bsfl %eax, %eax
addq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6e8c
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 0x6e7b
bsfl %edx, %eax
jmp 0x6ef3
testl %eax, %eax
jne 0x6eeb
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 0x6ec6
movdqu (%rsi), %xmm2
pcmpeqb %xmm0, %xmm2
pmovmskb %xmm2, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jne 0x6eee
addq $0x10, %rsi
movdqa 0x10(%rdi), %xmm0
addq $0x10, %rdi
jmp 0x6e94
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 0x6eeb
bsfl %eax, %eax
jmp 0x6ef3
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