LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.h
// Function: gdc::circular_queue_factory<char, gdc::circular_queue<char>>::create_private(unsigned long, bool, std::function<int (gdc::circular_queue<char>&)>)
static Q* create_private(
			size_type capacity,
			bool sync,
			mdinit_type metadata_initializer)
		{
			void* mdinit_context = &metadata_initializer;
			gdc_circular_queue* q = ::gdc_circular_queue_create_private(
				capacity,
				sync,
				default_metadata_init,
				mdinit_context);

			if (q == NULL)
			{
				std::string what("Failed to create private queue: ");
				what.append(::strerror(errno));
				throw circular_queue_error(what);
			}
			
			return reinterpret_cast<Q*>(q);
		}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rcx
leaq 0x12b(%rip), %rdx       # 0x2d410
callq 0x34d13
testq %rax, %rax
je 0x2d2f7
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0xab09(%rip), %rsi      # 0x37e07
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x11b1a
callq 0xc040
movl (%rax), %edi
callq 0xc160
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc8d0
pushq $0x18
popq %rdi
callq 0xc230
movq %rax, %rbx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2cee8
leaq 0x266a2(%rip), %rsi     # 0x539e8
leaq -0x54d(%rip), %rdx      # 0x2ce00
movq %rbx, %rdi
callq 0xc800
movq %rax, %r14
movq %rbx, %rdi
callq 0xc390
jmp 0x2d365
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xc978
movq %r14, %rdi
callq 0xc840
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.h
// Function: gdc::circular_queue_factory<char, gdc::circular_queue<char>>::delete_private(gdc::circular_queue<char>*)
static void delete_private(Q* q)
		{
			auto qq = reinterpret_cast<gdc_circular_queue*>(q);
			int status = ::gdc_circular_queue_delete_private(qq);
			
			if (status != 0)
			{
				std::string what("Failed to delete private queue: ");
				what.append(::strerror(errno));
				throw circular_queue_error(what);
			}
		}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0x34f20
testl %eax, %eax
jne 0x2d390
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0xaa91(%rip), %rsi      # 0x37e28
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x11b1a
callq 0xc040
movl (%rax), %edi
callq 0xc160
movq %rbx, %rdi
movq %rax, %rsi
callq 0xc8d0
pushq $0x18
popq %rdi
callq 0xc230
movq %rax, %rbx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2cee8
leaq 0x26609(%rip), %rsi     # 0x539e8
leaq -0x5e6(%rip), %rdx      # 0x2ce00
movq %rbx, %rdi
callq 0xc800
movq %rax, %r14
movq %rbx, %rdi
callq 0xc390
jmp 0x2d3fe
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xc978
movq %r14, %rdi
callq 0xc840
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/catch.hpp
// Function: Catch::ResultBuilder& Catch::ExpressionLhs<int const&>::captureExpression<(Catch::Internal::Operator)0, int>(int const&)
ResultBuilder& captureExpression( RhsT const& rhs ) {
        return m_rb
            .setResultType( Internal::compare<Op>( m_lhs, rhs ) )
            .setLhs( Catch::toString( m_lhs ) )
            .setRhs( Catch::toString( rhs ) )
            .setOp( Internal::OperatorTraits<Op>::getName() );
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rax
movl (%rax), %eax
xorl %esi, %esi
cmpl (%rbx), %eax
sete %sil
callq 0x10430
movq %rax, %r15
movq 0x8(%r14), %rax
movl (%rax), %esi
leaq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0xfe4b
movq %r15, %rdi
movq %r14, %rsi
callq 0x10444
movq %rax, %r14
movl (%rbx), %esi
leaq 0x30(%rsp), %rdi
callq 0xfe4b
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x1045a
movq %rax, %rbx
leaq 0xa95b(%rip), %rsi      # 0x37e49
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x11b1a
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x10470
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc978
leaq 0x30(%rsp), %rdi
callq 0xc978
leaq 0x50(%rsp), %rdi
callq 0xc978
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xc978
jmp 0x2d54c
jmp 0x2d549
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xc978
jmp 0x2d55d
jmp 0x2d55a
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xc978
movq %rbx, %rdi
callq 0xc840
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.h
// Function: gdc::circular_queue<char>::push(char const*, unsigned long)
bool push(const_pointer data, size_type len)
		{
			auto p = alloc(len);
			
			if (p == nullptr)
			{
				return false;
			}
			
			std::memmove(p, data, len);
			commit(len);
			return true;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq %rdx, %rsi
callq 0x34a77
movq %rax, %r15
testq %rax, %rax
je 0x2d5c6
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xc780
movq %r14, %rdi
movq %rbx, %rsi
callq 0x34afd
testq %r15, %r15
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.c
// Function: gdc_circular_queue_init
int
gdc_circular_queue_init(
	gdc_circular_queue *q,
	size_t capacity,
	int sync,
	int (*mdinit)(gdc_circular_queue*, void*),
	void* md_context)
{
	if (mdinit != NULL && mdinit(q, md_context) != 0)
	{
		return -1;
	}
	
	q->properties.sync = sync;
	atomic_store_explicit(&q->properties.capacity, capacity, memory_order_release);
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testq %rcx, %rcx
je 0x348f2
movq %r14, %rdi
movq %r8, %rsi
callq *%rcx
testl %eax, %eax
je 0x348f2
pushq $-0x1
popq %rax
jmp 0x34902
movl %ebp, 0x88(%r14)
movq %rbx, 0x80(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.c
// Function: gdc_circular_queue_data
void*
gdc_circular_queue_data(gdc_circular_queue *q)
{
	static long page_size = -1;
	
	if (page_size == -1)
	{
		page_size = sysconf(_SC_PAGESIZE);
	}
	
	char *p = (char*)q + page_size;
	return p;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1fc66(%rip), %rax     # 0x54580
cmpq $-0x1, %rax
jne 0x3492f
pushq $0x1e
popq %rdi
callq 0xc300
movq %rax, 0x1fc51(%rip)     # 0x54580
addq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x34abf
movq %rsi, %r14
movq %rdi, %rbx
movq 0x80(%rdi), %rax
cmpq %rsi, %rax
jbe 0x34ade
movq (%rbx), %rsi
movq 0x40(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rdx
callq 0x34999
cmpq %r14, %rax
jae 0x34aae
xorl %eax, %eax
jmp 0x34ab9
movq %rbx, %rdi
callq 0x3490f
addq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x43aa(%rip), %rdi      # 0x38e70
leaq 0x4350(%rip), %rsi      # 0x38e1d
leaq 0x43a4(%rip), %rcx      # 0x38e78
movl $0xce, %edx
callq 0xc310
leaq 0x43d0(%rip), %rdi      # 0x38eb5
leaq 0x4331(%rip), %rsi      # 0x38e1d
leaq 0x4385(%rip), %rcx      # 0x38e78
movl $0xcf, %edx
callq 0xc310
// File: /workspace/github_cpp_makefile_star2_O2/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 0x34b4b
movq %rsi, %r14
movq %rdi, %rbx
movq 0x80(%rdi), %rax
cmpq %rsi, %rax
jbe 0x34b6a
movq %rbx, %rdi
callq 0x34990
cmpq %r14, %rax
jb 0x34b89
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 0x431e(%rip), %rdi      # 0x38e70
leaq 0x42c4(%rip), %rsi      # 0x38e1d
leaq 0x437a(%rip), %rcx      # 0x38eda
movl $0xe2, %edx
callq 0xc310
leaq 0x4344(%rip), %rdi      # 0x38eb5
leaq 0x42a5(%rip), %rsi      # 0x38e1d
leaq 0x435b(%rip), %rcx      # 0x38eda
movl $0xe3, %edx
callq 0xc310
leaq 0x4387(%rip), %rdi      # 0x38f17
leaq 0x4286(%rip), %rsi      # 0x38e1d
leaq 0x433c(%rip), %rcx      # 0x38eda
movl $0xe4, %edx
callq 0xc310
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rcx, %r13
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
callq 0xc8b0
pushq $-0x1
popq %r12
cmpl $-0x1, %eax
jne 0x34be0
callq 0xc040
cmpl $0x2, (%rax)
jne 0x34c8c
movl %ebp, 0xc(%rsp)
movq %r14, %rdi
movl $0xc2, %esi
movl $0x1c0, %edx            # imm = 0x1C0
callq 0xc7c0
cmpl $-0x1, %eax
je 0x34c25
movl %eax, %ebp
movq %rbx, 0x10(%rsp)
movq %r15, %rdi
callq 0x34cb6
movq %rax, %rbx
addq %r15, %rbx
movl %ebp, %edi
movq %rbx, %rsi
callq 0xc660
testl %eax, %eax
je 0x34c2f
movl %ebp, %edi
callq 0xc910
movq %r14, %rdi
callq 0xc8b0
jmp 0x34c8c
pushq $0x3
popq %rdx
pushq $0x1
popq %rcx
xorl %edi, %edi
movq %rbx, %rsi
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0xc850
cmpq $-0x1, %rax
je 0x34c79
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movl 0xc(%rsp), %edx
movq %r13, %rcx
movq 0x10(%rsp), %r8
callq 0x348d0
cmpl $-0x1, %eax
je 0x34c79
movq %r12, %rdi
movq %rbx, %rsi
callq 0xc280
testl %eax, %eax
je 0x34c9e
movq %r14, %rdi
callq 0xc8b0
movl %ebp, %edi
callq 0xc910
pushq $-0x1
popq %r12
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
callq 0xc910
testl %eax, %eax
pushq $-0x1
popq %r12
jne 0x34c25
xorl %r12d, %r12d
jmp 0x34c8c
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1e
popq %rdi
callq 0xc300
cmpq $-0x1, %rax
je 0x34cea
movq %rax, %rcx
testq %rax, %rax
jle 0x34cf1
testq %rbx, %rbx
je 0x34cec
decq %rbx
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
addq $0x2, %rax
imulq %rax, %rcx
jmp 0x34cec
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
retq
leaq 0x4308(%rip), %rdi      # 0x39000
leaq 0x430f(%rip), %rsi      # 0x3900e
leaq 0x4369(%rip), %rcx      # 0x3906f
pushq $0x30
popq %rdx
callq 0xc310
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %r13
lock
xaddl %r13d, 0x1fa91(%rip)    # 0x547cc
callq 0xc6b0
leaq 0x42ad(%rip), %rsi      # 0x38ff4
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 0x34ba8
cmpl $-0x1, %eax
je 0x34d8f
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x34da1
movq %rax, %rbx
movq %r14, %rdi
callq 0xc8b0
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_O2/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 0x34f56
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x34937
movq %rax, %r14
movq %rax, %rdi
callq 0x34cb6
addq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xc280
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe1e(%rip), %r15       # 0x200c
leaq 0xe28(%rip), %rsi       # 0x201d
movq %r15, %rdi
xorl %eax, %eax
callq 0x1050
cvtss2sd (%r14), %xmm0
leaq 0xe06(%rip), %r14       # 0x2011
movq %r14, %rdi
movb $0x1, %al
callq 0x1050
leaq 0xe04(%rip), %rsi       # 0x2020
movq %r15, %rdi
xorl %eax, %eax
callq 0x1050
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_O2/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 0xdbc(%rip), %rdi       # 0x2023
xorl %eax, %eax
callq 0x1050
leaq 0xdb8(%rip), %rdi       # 0x202d
leaq 0x2dc4(%rip), %rsi      # 0x4040
leaq 0x2dc2(%rip), %rdx      # 0x4045
leaq 0x2dbe(%rip), %rcx      # 0x4048
xorl %eax, %eax
callq 0x1050
leaq 0xde6(%rip), %rdi       # 0x207e
callq 0x1040
leaq 0xd68(%rip), %r15       # 0x200c
leaq 0xd8b(%rip), %rbx       # 0x2036
movq %r15, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1050
movss 0xd44(%rip), %xmm0      # 0x2004
callq 0x13ea
leaq 0xd6c(%rip), %r14       # 0x2038
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1050
movss 0xd27(%rip), %xmm0      # 0x2008
callq 0x13ea
leaq 0xd98(%rip), %r13       # 0x2085
movq %r13, %rdi
callq 0x1040
pushq $0xa
popq %r12
movl %r12d, %edi
callq 0x1030
leaq 0xd59(%rip), %rdi       # 0x2061
callq 0x1040
movss 0xcef(%rip), %xmm0      # 0x2004
movss 0xceb(%rip), %xmm1      # 0x2008
callq 0x115c
leaq 0xd55(%rip), %rdi       # 0x207e
callq 0x1040
movq %r15, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1050
movss 0xcc1(%rip), %xmm0      # 0x2004
callq 0x13ea
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1050
movss 0xcab(%rip), %xmm0      # 0x2008
callq 0x13ea
movq %r13, %rdi
callq 0x1040
movl %r12d, %edi
callq 0x1030
leaq 0xcf6(%rip), %rdi       # 0x206f
callq 0x1040
leaq -0x30(%rbp), %r13
movq %r13, %rdi
leaq -0x2c(%rbp), %r12
movq %r12, %rsi
callq 0x11c7
leaq 0xce6(%rip), %rdi       # 0x207e
callq 0x1040
movq %r15, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1050
movss (%r13), %xmm0
callq 0x13ea
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1050
movss (%r12), %xmm0
callq 0x13ea
leaq 0xcb1(%rip), %rdi       # 0x2085
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_O2/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 0x5842
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x5843
movq 0x8(%rbx), %rdi
callq 0x3250
movq %rbx, %rdi
popq %rbx
jmp 0x3250
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
je 0x587f
movslq 0x4(%rbx), %rax
cmpl %ebp, %eax
jle 0x587f
testl %eax, %eax
je 0x5872
decq %rax
movl %eax, 0x4(%rbx)
movslq 0x10(%rbx), %rdi
imulq %rax, %rdi
addq 0x8(%rbx), %rdi
jmp 0x5874
xorl %edi, %edi
movq 0x20(%rbx), %rsi
xorl %eax, %eax
callq *0x18(%rbx)
jmp 0x5852
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_O2/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 0x5957
movl 0x4(%rbx), %eax
jmp 0x5959
xorl %eax, %eax
movslq %eax, %r15
movq %r14, %rdi
callq 0x30d0
leal (%r15,%rax), %esi
incl %esi
movq %rbx, %rdi
callq 0x57fc
addq 0x8(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x31b0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdx
callq 0x3210
movq %rax, %r15
subq %rbx, %r15
testq %rax, %rax
cmoveq %r14, %r15
pushq $0x3c
popq %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3210
testq %rax, %rax
je 0x5a26
movq %rax, %r14
leaq (%rbx,%r15), %rdx
subq %rax, %rdx
pushq $0x3e
popq %rsi
movq %rax, %rdi
callq 0x3210
testq %rax, %rax
je 0x5a26
movq %r14, %rcx
notq %rcx
addq %rcx, %rax
incq %r14
movq %r14, %rbx
movq %rax, %r15
movabsq $-0x100000000, %r13     # imm = 0xFFFFFFFF00000000
movq %r15, %rax
shlq $0x20, %rax
movq %r15, %r12
movq %rax, %r14
subq $0x1, %r15
jb 0x5a5c
callq 0x31f0
movq (%rax), %rcx
movsbq -0x1(%rbx,%r12), %rdx
leaq (%r14,%r13), %rax
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0x5a37
leaq (%rbx,%r12), %r15
xorl %ebp, %ebp
cmpq %rbp, %r12
je 0x5a89
callq 0x31f0
movq (%rax), %rax
movsbq (%rbx,%rbp), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x5a83
incq %rbp
addq %r13, %r14
jmp 0x5a62
addq %rbp, %rbx
movq %rbx, %r15
sarq $0x20, %r14
xorl %eax, %eax
cmpl %ebp, %r12d
cmovneq %r15, %rax
testq %r15, %r15
cmoveq %r15, %r14
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
leaq 0x2937(%rip), %rsi      # 0x83f8
callq 0x3230
testq %rax, %rax
je 0x5aec
movq %rax, %r14
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rcx
callq 0x33c0
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
jmp 0x5aee
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5b93
movdqu (%rdi), %xmm0
movdqu (%rsi), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %ecx
cmpl $0xffff, %ecx           # imm = 0xFFFF
je 0x5b86
notl %ecx
bsfl %ecx, %eax
jmp 0x5bf1
pushq $0x10
popq %rcx
subl %eax, %ecx
addq %rcx, %rdi
addq %rcx, %rsi
subl %ecx, %edx
cmpl $0x10, %edx
jl 0x5bc6
prefetchnta 0x1c0(%rdi)
prefetchnta 0x1c0(%rsi)
movdqu (%rsi), %xmm0
pcmpeqb (%rdi), %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jne 0x5bec
addq $0x10, %rdi
addq $0x10, %rsi
addl $-0x10, %edx
jmp 0x5b93
movdqu (%rdi), %xmm0
movdqu (%rsi), %xmm1
pcmpeqb %xmm0, %xmm1
pushq $-0x1
popq %rax
movl %edx, %ecx
shll %cl, %eax
pmovmskb %xmm1, %ecx
xorl $0xffff, %ecx           # imm = 0xFFFF
notl %eax
andl %ecx, %eax
jne 0x5bee
xorl %eax, %eax
retq
notl %eax
bsfl %eax, %eax
addq %rax, %rdi
addq %rax, %rsi
movzbl (%rdi), %eax
movzbl (%rsi), %ecx
subl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5c32
movdqu (%rdi), %xmm0
movdqu (%rsi), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %ecx
cmpl $0xffff, %ecx           # imm = 0xFFFF
je 0x5c37
notl %ecx
bsfl %ecx, %eax
retq
movq %rdi, %rax
jmp 0x5c47
pushq $0x10
popq %rcx
subl %eax, %ecx
movq %rdi, %rax
addq %rcx, %rax
addq %rcx, %rsi
subl %ecx, %edx
subl %eax, %edi
cmpl $0x10, %edx
jl 0x5c80
prefetchnta 0x1c0(%rax)
prefetchnta 0x1c0(%rsi)
movdqu (%rsi), %xmm0
pcmpeqb (%rax), %xmm0
pmovmskb %xmm0, %ecx
cmpl $0xffff, %ecx           # imm = 0xFFFF
jne 0x5ca8
addq $0x10, %rax
addq $0x10, %rsi
addl $-0x10, %edx
addl $-0x10, %edi
jmp 0x5c49
movdqu (%rax), %xmm0
movdqu (%rsi), %xmm1
pcmpeqb %xmm0, %xmm1
pushq $-0x1
popq %rax
movl %edx, %ecx
shll %cl, %eax
pmovmskb %xmm1, %ecx
xorl $0xffff, %ecx           # imm = 0xFFFF
notl %eax
andl %ecx, %eax
je 0x5cb0
bsfl %eax, %eax
jmp 0x5cad
notl %ecx
bsfl %ecx, %eax
subl %edi, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5cfa
pushq $0x2
popq %rdx
movl %ebp, %edi
xorl %esi, %esi
callq 0x33a0
movq %rax, %r14
pushq $0x1
popq %rcx
xorl %edi, %edi
movq %rax, %rsi
movl %ecx, %edx
movl %ebp, %r8d
xorl %r9d, %r9d
callq 0x3380
movq %rax, %rbx
movl %ebp, %edi
callq 0x33d0
jmp 0x5cfd
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_O2/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:
movl %edi, %edx
andl $0xf, %edx
andq $-0x10, %rdi
pcmpeqd %xmm0, %xmm0
movdqa (%rdi), %xmm1
pcmpeqb %xmm0, %xmm1
addl %edx, %esi
pushq $-0x1
popq %rax
movl %eax, %r9d
movl %esi, %ecx
shll %cl, %r9d
pmovmskb %xmm1, %r10d
notl %r10d
cmpl $0x10, %esi
notl %r9d
movl $0xffff, %r8d           # imm = 0xFFFF
cmovll %r9d, %r8d
movl %edx, %ecx
shrl %cl, %r8d
shll %cl, %r8d
andl %r10d, %r8d
testw %r8w, %r8w
jne 0x5d9c
cmpl $0x10, %esi
jl 0x5d9c
prefetchnta 0x210(%rdi)
movdqa 0x10(%rdi), %xmm1
addq $0x10, %rdi
addl $-0x10, %esi
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %r8d
notl %r8d
addl $-0x10, %edx
jmp 0x5d6d
movl %eax, %r9d
movl %esi, %ecx
shll %cl, %r9d
cmpl $0x10, %esi
notl %r9d
movl $0xffff, %ecx           # imm = 0xFFFF
cmovll %r9d, %ecx
andw %r8w, %cx
je 0x5dd3
movzwl %cx, %eax
bsrl %eax, %eax
cltq
movzbl (%rdi,%rax), %ecx
xorl $0xff, %ecx
bsrl %ecx, %ecx
subl %edx, %eax
leal (%rcx,%rax,8), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl %edi, %edx
andl $0xf, %edx
andq $-0x10, %rdi
pxor %xmm0, %xmm0
movdqa (%rdi), %xmm1
pcmpeqb %xmm0, %xmm1
addl %edx, %esi
pushq $-0x1
popq %rax
movl %eax, %r9d
movl %esi, %ecx
shll %cl, %r9d
pmovmskb %xmm1, %r10d
notl %r10d
cmpl $0x10, %esi
notl %r9d
movl $0xffff, %r8d           # imm = 0xFFFF
cmovll %r9d, %r8d
movl %edx, %ecx
shrl %cl, %r8d
shll %cl, %r8d
andl %r10d, %r8d
testw %r8w, %r8w
jne 0x5e48
cmpl $0x10, %esi
jl 0x5e48
prefetchnta 0x210(%rdi)
movdqa 0x10(%rdi), %xmm1
addq $0x10, %rdi
addl $-0x10, %esi
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %r8d
notl %r8d
addl $-0x10, %edx
jmp 0x5e19
movl %eax, %r9d
movl %esi, %ecx
shll %cl, %r9d
cmpl $0x10, %esi
notl %r9d
movl $0xffff, %ecx           # imm = 0xFFFF
cmovll %r9d, %ecx
andw %r8w, %cx
je 0x5e79
movzwl %cx, %eax
bsrl %eax, %eax
cltq
movzbl (%rdi,%rax), %ecx
bsrl %ecx, %ecx
subl %edx, %eax
leal (%rcx,%rax,8), %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5f13
callq 0x31f0
movq (%rax), %rcx
movsbq -0x1(%rbx,%r14), %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
je 0x5f13
movb $0x0, -0x1(%rbx,%r14)
decq %r14
jne 0x5ef5
xorl %r14d, %r14d
movq %rbx, %rax
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5f84
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 0x5fc0
callq 0x6029
movq 0x6023(%rip), %rcx      # 0xbfd8
movq (%rcx), %rsi
movq %rax, %rdi
callq 0x3220
movq 0x6011(%rip), %r15      # 0xbfd8
movq (%r15), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x30d0
cmpb $0x3a, -0x1(%rbx,%rax)
jne 0x6016
movq (%r15), %rbx
callq 0x3040
movslq (%rax), %rdi
leaq 0x620a(%rip), %rax      # 0xc200
movq (%rax,%rdi,8), %r14
callq 0x30a0
leaq 0x23f4(%rip), %rsi      # 0x83fa
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x32d0
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x33b0
pushq $0x1
popq %rdi
callq 0x3330
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/msutil.c
// Function: getprogname
char const *
getprogname(void)
{
    static char *progname;

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

    return  progname;
}

// Assembly:
movq 0x6778(%rip), %rax      # 0xc7a8
testq %rax, %rax
je 0x6036
retq
pushq %rbx
subq $0x3f0, %rsp            # imm = 0x3F0
callq 0x32f0
leaq 0x23b7(%rip), %rsi      # 0x8401
movq %rsp, %rbx
movq %rbx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x3070
movl $0x3e7, %edx            # imm = 0x3E7
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x31e0
testl %eax, %eax
sets %cl
cmpl $0x3e7, %eax            # imm = 0x3E7
sete %dl
orb %cl, %dl
je 0x607e
xorl %eax, %eax
jmp 0x60a9
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movb $0x0, (%rsp,%rax)
pushq $0x2f
popq %rsi
movq %rbx, %rdi
callq 0x3200
leaq 0x1(%rax), %rdi
testq %rax, %rax
cmoveq %rbx, %rdi
callq 0x3390
movq %rax, 0x66ff(%rip)      # 0xc7a8
addq $0x3f0, %rsp            # imm = 0x3F0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x6288
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movslq %edx, %rax
movq %rax, 0x10(%rsp)
pushq $0x20
popq %r12
xorl %ebp, %ebp
movl %edx, %eax
movq %rax, 0x8(%rsp)
cmpq 0x10(%rsp), %rbp
jge 0x627a
movq 0x8(%rsp), %rax
movl %eax, %eax
movq %rax, 0x8(%rsp)
pushq $0x9
popq %rdi
movq %r15, %rsi
callq 0x33b0
xorl %r13d, %r13d
cmpq $0x10, %r13
je 0x61cc
cmpq $0x20, %r13
jne 0x61d7
jmp 0x6209
movl %r12d, %edi
movq %r15, %rsi
callq 0x33b0
leal (%rbp,%r13), %eax
movl %r12d, %edi
cmpl %ebx, %eax
jge 0x61fc
callq 0x31f0
movq (%rax), %rcx
movzbl (%r14,%r13), %eax
testb $0x40, 0x1(%rcx,%rax,2)
pushq $0x2e
popq %rdi
je 0x61fc
movl %eax, %edi
movq %r15, %rsi
callq 0x33b0
incq %r13
jmp 0x61be
pushq $0x7c
popq %rdi
movq %r15, %rsi
callq 0x33b0
xorl %r13d, %r13d
cmpq $0x20, %r13
je 0x6255
cmpq %r13, 0x8(%rsp)
je 0x6255
cmpq $0x10, %r13
leaq 0x29b7(%rip), %rdx      # 0x8be6
leaq 0x2c25(%rip), %rax      # 0x8e5b
cmoveq %rax, %rdx
movzbl (%r14,%r13), %ecx
movq %r15, %rdi
leaq 0x21c5(%rip), %rsi      # 0x840e
xorl %eax, %eax
callq 0x32d0
incq %r13
jmp 0x6217
pushq $0xa
popq %rdi
movq %r15, %rsi
callq 0x33b0
addq $0x20, %rbp
movq 0x8(%rsp), %rax
addl $-0x20, %eax
movq %rax, 0x8(%rsp)
addq $0x20, %r14
jmp 0x6199
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x63ae
movb %r8b, %bl
movb %r9b, %al
subl %eax, %ebx
jmp 0x63c8
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_O2/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 0x6400
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_O2/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 0x64b8
movq %rdi, %r14
movsbl %sil, %ebp
pushq $0x1
popq %r12
pushq $0x10
popq %r15
movq %rdi, %rax
movq %rax, %rdi
movl %ebp, %esi
callq 0x30c0
testq %rax, %rax
je 0x646c
incl %r12d
incq %rax
addq $0x10, %r15
jmp 0x6451
movq %r15, %rdi
callq 0x3280
movq %rax, %r15
movq %rax, %r13
addq $0x8, %r13
movq %r14, -0x8(%r13)
movq %r14, %rdi
movl %ebp, %esi
callq 0x30c0
testq %rax, %rax
je 0x64aa
movq %rax, %rcx
subq %r14, %rcx
movq %rcx, (%r13)
movb $0x0, (%rax)
incq %rax
addq $0x10, %r13
movq %rax, %r14
jmp 0x647e
movq %r14, %rdi
callq 0x30d0
movq %rax, (%r13)
jmp 0x64be
xorl %r12d, %r12d
xorl %r15d, %r15d
testq %rbx, %rbx
je 0x64c6
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_O2/ctSkennerton[P]fxtract/util/msutil.c
// Function: slurp
MEMBUF
slurp(const char *filename)
{
    MEMBUF      ret = NILBUF;
    int         fd = filename && *filename && strcmp(filename, "-") ? open(filename, O_RDONLY) : 0;
    struct stat s;
    if (fd < 0 || fstat(fd, &s))
        goto ERROR;

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
testq %rdi, %rdi
je 0x6564
movzbl (%rdi), %eax
testl %eax, %eax
je 0x6564
cmpl $0x2d, %eax
jne 0x6550
cmpb $0x0, 0x1(%rdi)
je 0x6564
xorl %r14d, %r14d
xorl %esi, %esi
xorl %eax, %eax
callq 0x3150
movl %eax, %ebx
testl %eax, %eax
jns 0x6566
jmp 0x6580
xorl %ebx, %ebx
leaq 0x8(%rsp), %rsi
movl %ebx, %edi
callq 0x3350
testl %eax, %eax
je 0x65a6
xorl %r14d, %r14d
movl %ebx, %edi
callq 0x33d0
movq %r14, %rdi
callq 0x3250
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %r14, %rax
movq %r15, %rdx
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xf000, %eax           # imm = 0xF000
andl 0x20(%rsp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x65de
movl 0x38(%rsp), %r15d
testq %r15, %r15
je 0x665a
leal 0x1(%r15), %eax
movslq %eax, %rdi
pushq $0x1
popq %rsi
callq 0x3140
movq %rax, %r14
movslq %r15d, %r15
jmp 0x6660
movl $0x1001, %edi           # imm = 0x1001
callq 0x3280
movq %rax, %r14
movl $0x1000, %r13d          # imm = 0x1000
xorl %r15d, %r15d
leaq (%r14,%r15), %rsi
movslq %r13d, %rdx
subq %r15, %rdx
movl %ebx, %edi
callq 0x32e0
movq %rax, %r12
testl %r12d, %r12d
jle 0x6643
movl %r13d, %eax
subl %r15d, %eax
cmpl %r12d, %eax
jne 0x6637
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
jmp 0x65f4
js 0x6579
leaq 0x1(%r15), %rsi
movq %r14, %rdi
callq 0x3340
movq %rax, %r14
jmp 0x6678
xorl %r14d, %r14d
xorl %r15d, %r15d
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x32e0
movl %eax, %eax
cmpq %rax, %r15
jne 0x6579
movl %ebx, %edi
callq 0x33d0
movb $0x0, (%r14,%r15)
jmp 0x658e
// File: /workspace/github_cpp_makefile_star2_O2/ctSkennerton[P]fxtract/util/msutil.c
// Function: strim
char *
strim(char *s)
{
    char    *e = s + strlen(s);
    while (e > s && isspace(e[-1])) --e;
    *e = 0;
    while (isspace(*s)) ++s;
    return  s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x30d0
movq %rax, %r14
addq %rbx, %r14
callq 0x31f0
movq %r14, %rcx
cmpq %rbx, %r14
jbe 0x66bb
movq (%rax), %rdx
leaq -0x1(%rcx), %r14
movsbq -0x1(%rcx), %rsi
testb $0x20, 0x1(%rdx,%rsi,2)
jne 0x66a0
movb $0x0, (%rcx)
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x66c4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x684f
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 0x686d
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 0x6861
bsfl %edx, %eax
jmp 0x68c5
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3360
testl %eax, %eax
jne 0x68be
pushq $0x10
popq %rax
subl %ecx, %eax
addq %rax, %rbx
pxor %xmm2, %xmm2
movdqa (%rbx), %xmm3
movdqa %xmm3, %xmm4
pcmpeqb %xmm2, %xmm4
pmovmskb %xmm4, %eax
movdqa %xmm3, %xmm4
pcmpeqb %xmm0, %xmm4
pcmpeqb %xmm1, %xmm3
testl %eax, %eax
jne 0x68a3
por %xmm3, %xmm4
pmovmskb %xmm4, %eax
testl %eax, %eax
jne 0x68c2
addq $0x10, %rbx
jmp 0x6871
movzwl %ax, %eax
por %xmm3, %xmm4
pmovmskb %xmm4, %ecx
leal -0x1(%rax), %edx
notl %eax
andl %edx, %eax
andl %ecx, %eax
je 0x68be
bsfl %eax, %eax
jmp 0x68c5
xorl %ebx, %ebx
jmp 0x68c8
bsfl %eax, %eax
addq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x693c
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 0x692d
bsfl %edx, %eax
jmp 0x699e
testl %eax, %eax
jne 0x6996
pushq $0x10
popq %rax
subl %ecx, %eax
addq %rax, %rdi
addq %rax, %rsi
pxor %xmm0, %xmm0
movdqa (%rdi), %xmm1
movdqa %xmm1, %xmm2
pcmpeqb %xmm0, %xmm2
pmovmskb %xmm2, %eax
testl %eax, %eax
jne 0x6971
movdqu (%rsi), %xmm2
pcmpeqb %xmm2, %xmm1
pmovmskb %xmm1, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jne 0x6999
addq $0x10, %rdi
addq $0x10, %rsi
jmp 0x6940
movzwl %ax, %eax
movdqu (%rsi), %xmm0
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %ecx
xorl $0xffff, %ecx           # imm = 0xFFFF
leal -0x1(%rax), %edx
notl %eax
andl %edx, %eax
andl %ecx, %eax
je 0x6996
bsfl %eax, %eax
jmp 0x699e
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