LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.h
// Function: gdc::circular_queue_factory<char, gdc::circular_queue<char>>::unmap_shared(gdc::circular_queue<char>*)
static void unmap_shared(Q* q)
		{
			auto qq = reinterpret_cast<gdc_circular_queue*>(q);
			int status = ::gdc_circular_queue_unmap_shared(qq);
			
			if (status != 0)
			{
				std::string what("Failed to unmap shared memory queue: ");
				what.append(::strerror(errno));
				throw circular_queue_error(what);
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7c710
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x675dd
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xeb70
movq -0x58(%rbp), %rdx
leaq 0x1894e(%rip), %rsi     # 0x7fe80
leaq -0x38(%rbp), %rdi
callq 0x18c80
jmp 0x6753d
leaq -0x39(%rbp), %rdi
callq 0xe710
callq 0xe070
movl (%rax), %edi
callq 0xe1c0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0xec20
jmp 0x67560
movl $0x18, %edi
callq 0xe310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x66900
jmp 0x6757f
movq -0x60(%rbp), %rdi
leaq 0x4d3f6(%rip), %rsi     # 0xb4980
leaq -0xf51(%rip), %rdx      # 0x66640
callq 0xeb10
jmp 0x675ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xe710
jmp 0x675e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x675d2
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0xe4c0
leaq -0x38(%rbp), %rdi
callq 0xecd8
jmp 0x675e3
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xeb60
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
movq -0x20(%rbp), %rcx
leaq 0x1ed(%rip), %rdx       # 0x678a0
callq 0x7c350
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x6778a
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xeb70
movq -0x68(%rbp), %rdx
leaq 0x187c7(%rip), %rsi     # 0x7fea6
leaq -0x48(%rbp), %rdi
callq 0x18c80
jmp 0x676ea
leaq -0x49(%rbp), %rdi
callq 0xe710
callq 0xe070
movl (%rax), %edi
callq 0xe1c0
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0xec20
jmp 0x6770d
movl $0x18, %edi
callq 0xe310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x70(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x66900
jmp 0x6772c
movq -0x70(%rbp), %rdi
leaq 0x4d249(%rip), %rsi     # 0xb4980
leaq -0x10fe(%rip), %rdx     # 0x66640
callq 0xeb10
jmp 0x6779d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0xe710
jmp 0x67794
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x6777f
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0xe4c0
leaq -0x48(%rbp), %rdi
callq 0xecd8
jmp 0x67794
movq -0x28(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xeb60
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7c6f0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x6788d
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xeb70
movq -0x58(%rbp), %rdx
leaq 0x186e5(%rip), %rsi     # 0x7fec7
leaq -0x38(%rbp), %rdi
callq 0x18c80
jmp 0x677ed
leaq -0x39(%rbp), %rdi
callq 0xe710
callq 0xe070
movl (%rax), %edi
callq 0xe1c0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0xec20
jmp 0x67810
movl $0x18, %edi
callq 0xe310
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x66900
jmp 0x6782f
movq -0x60(%rbp), %rdi
leaq 0x4d146(%rip), %rsi     # 0xb4980
leaq -0x1201(%rip), %rdx     # 0x66640
callq 0xeb10
jmp 0x6789c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xe710
jmp 0x67893
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x67882
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0xe4c0
leaq -0x38(%rbp), %rdi
callq 0xecd8
jmp 0x67893
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xeb60
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.h
// Function: gdc::circular_queue_factory<char, gdc::circular_queue<char>>::default_metadata_init(gdc_circular_queue*, void*)
static int default_metadata_init(gdc_circular_queue* q, void* context)
		{
			if (context != NULL)
			{
				auto init = reinterpret_cast<mdinit_type*>(context);
				auto qq = reinterpret_cast<Q*>(q);
				return (*init)(*qq);
			}
			
			return 0;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x678d9
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x678f0
movl %eax, -0x4(%rbp)
jmp 0x678e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq (%rax), %rcx
movq %rcx, -0xb0(%rbp)
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x67e60
movq -0xb0(%rbp), %rdi
movzbl %al, %esi
callq 0x158c0
movq %rax, %rcx
movq -0xa8(%rbp), %rax
movq %rcx, -0xa0(%rbp)
movq 0x8(%rax), %rax
movl (%rax), %esi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x14e00
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x158f0
movq %rax, -0x90(%rbp)
jmp 0x67d37
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq -0x60(%rbp), %rdi
callq 0x14e00
jmp 0x67d48
movq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x15930
movq %rax, -0xb8(%rbp)
jmp 0x67d61
callq 0x67e90
movq %rax, -0xc0(%rbp)
jmp 0x67d6f
leaq -0x81(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0xeb70
movq -0xc0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
leaq -0x80(%rbp), %rdi
callq 0x18c80
jmp 0x67d9b
movq -0xb8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x15970
movq %rax, -0xd0(%rbp)
jmp 0x67db4
leaq -0x80(%rbp), %rdi
callq 0xecd8
leaq -0x81(%rbp), %rdi
callq 0xe710
leaq -0x60(%rbp), %rdi
callq 0xecd8
leaq -0x30(%rbp), %rdi
callq 0xecd8
movq -0xd0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x67e3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x67e36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x67e2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xecd8
leaq -0x81(%rbp), %rdi
callq 0xe710
leaq -0x60(%rbp), %rdi
callq 0xecd8
leaq -0x30(%rbp), %rdi
callq 0xecd8
movq -0x38(%rbp), %rdi
callq 0xeb60
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x20(%rbp), %rsi
callq 0x68360
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x68326
movb $0x0, -0x1(%rbp)
jmp 0x68348
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xea60
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x683a0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.h
// Function: gdc::circular_queue<char>::alloc(unsigned long) const
pointer alloc(size_type len) const
		{
			auto q = reinterpret_cast<const gdc_circular_queue*>(this);
			auto qq = const_cast<gdc_circular_queue*>(q);
			auto p = ::gdc_circular_queue_alloc(qq, len);
			return reinterpret_cast<pointer>(p);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7be40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.h
// Function: gdc::circular_queue<char>::peek() const
const_pointer peek() const
		{
			auto q = reinterpret_cast<const gdc_circular_queue*>(this);
			auto qq = const_cast<gdc_circular_queue*>(q);
			auto p = ::gdc_circular_queue_peek(qq);
			return reinterpret_cast<const_pointer>(p);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7bcc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x7b9de
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
je 0x7b9de
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7ba09
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x88(%rax)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, 0x80(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $-0x1, 0x39ce4(%rip)    # 0xb5738
jne 0x7ba67
movl $0x1e, %edi
callq 0xe430
movq %rax, 0x39cd1(%rip)     # 0xb5738
movq -0x8(%rbp), %rax
addq 0x39cc6(%rip), %rax     # 0xb5738
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.c
// Function: gdc_circular_queue_available
size_t
gdc_circular_queue_available(gdc_circular_queue *q)
{
	size_t rp = atomic_load_explicit(&q->rpos, memory_order_relaxed);
	size_t wp = atomic_load_explicit(&q->wpos, memory_order_relaxed);
	size_t n = available(q, rp, wp);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7bb50
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.c
// Function: available
size_t
available(gdc_circular_queue *q, size_t rp, size_t wp)
{
	size_t capacity = gdc_circular_queue_capacity(q);
	size_t n;
	
	if (wp >= rp)
	{
		// _____xxxxx_____
		//      ^    ^
		//     rp    wp
		//
		// Scenario 2 (empty):
		// _______________
		//      ^
		//    wp==rp
		n = wp - rp;
	}
	else
	{
		// xxxxx_____xxxxx
		//      ^    ^
		//     wp    rp
		n = capacity + wp - rp;
	}
	
	assert(n < capacity);
	
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7ba80
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0x7bb89
movq -0x18(%rbp), %rax
subq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x7bb99
movq -0x20(%rbp), %rax
addq -0x18(%rbp), %rax
subq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x7bba5
jmp 0x7bbc4
leaq 0x55a6(%rip), %rdi      # 0x81152
leaq 0x5482(%rip), %rsi      # 0x81035
movl $0x10a, %edx            # imm = 0x10A
leaq 0x55a0(%rip), %rcx      # 0x8115f
callq 0xe440
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.c
// Function: gdc_circular_queue_space
size_t
gdc_circular_queue_space(gdc_circular_queue *q)
{
	size_t rp = atomic_load_explicit(&q->rpos, memory_order_relaxed);
	size_t wp = atomic_load_explicit(&q->wpos, memory_order_relaxed);
	size_t n = space(q, rp, wp);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7bc30
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.c
// Function: space
size_t
space(gdc_circular_queue *q, size_t rp, size_t wp)
{
	size_t capacity = gdc_circular_queue_capacity(q);
	size_t n;
	
	if (wp >= rp)
	{
		// _____xxxxx_____
		//      ^    ^
		//     rp    wp
		//
		// Scenario 2 (empty):
		// _______________
		//      ^
		//    wp==rp
		n = capacity + rp - wp - 1;
	}
	else
	{
		// xxxxx_____xxxxx
		//      ^    ^
		//     wp    rp
		n = rp - wp;
	}
	
	assert(n < capacity);
	
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7ba80
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jb 0x7bc71
movq -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
subq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7bc7d
movq -0x10(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x7bc89
jmp 0x7bca8
leaq 0x54c2(%rip), %rdi      # 0x81152
leaq 0x539e(%rip), %rsi      # 0x81035
movl $0x12a, %edx            # imm = 0x12A
leaq 0x54f3(%rip), %rcx      # 0x81196
callq 0xe440
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.c
// Function: gdc_circular_queue_peek
void*
gdc_circular_queue_peek(gdc_circular_queue *q)
{
	size_t rp = atomic_load_explicit(&q->rpos, memory_order_relaxed);
	size_t wp = atomic_load_explicit(&q->wpos, memory_order_relaxed);
	
	if (rp == wp)
	{
		// Queue is empty.
		return NULL;
	}
	
	if (q->properties.sync)
	{
		// Memory fence after relaxed read of wpos.
		atomic_thread_fence(memory_order_acquire);
	}
	
	char *d = gdc_circular_queue_data(q);
	char *p = &d[rp];
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x7bd07
movq $0x0, -0x8(%rbp)
jmp 0x7bd35
movq -0x10(%rbp), %rax
cmpl $0x0, 0x88(%rax)
je 0x7bd14
movq -0x10(%rbp), %rdi
callq 0x7ba40
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.c
// Function: advance_rpos
void
advance_rpos(gdc_circular_queue *q, size_t len)
{
	size_t capacity = gdc_circular_queue_capacity(q);
	size_t rp = atomic_load_explicit(&q->rpos, memory_order_relaxed);
	rp = (rp + len) % capacity;
	assert(rp <= 2 * capacity);
	atomic_store_explicit(&q->rpos, rp, memory_order_relaxed);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7ba80
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq %rcx
cmpq %rcx, %rax
ja 0x7be06
jmp 0x7be25
leaq 0x53bc(%rip), %rdi      # 0x811c9
leaq 0x5221(%rip), %rsi      # 0x81035
movl $0x140, %edx            # imm = 0x140
leaq 0x53bc(%rip), %rcx      # 0x811dc
callq 0xe440
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x7be59
jmp 0x7be78
leaq 0x5228(%rip), %rdi      # 0x81088
leaq 0x51ce(%rip), %rsi      # 0x81035
movl $0xce, %edx
leaq 0x521d(%rip), %rcx      # 0x81090
callq 0xe440
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7ba80
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x7be97
jmp 0x7beb6
leaq 0x522f(%rip), %rdi      # 0x810cd
leaq 0x5190(%rip), %rsi      # 0x81035
movl $0xcf, %edx
leaq 0x51df(%rip), %rcx      # 0x81090
callq 0xe440
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x7bc30
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jbe 0x7bf0c
movq $0x0, -0x8(%rbp)
jmp 0x7bf2d
movq -0x10(%rbp), %rdi
callq 0x7ba40
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0x7bf59
jmp 0x7bf78
leaq 0x5128(%rip), %rdi      # 0x81088
leaq 0x50ce(%rip), %rsi      # 0x81035
movl $0xe2, %edx
leaq 0x517f(%rip), %rcx      # 0x810f2
callq 0xe440
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7ba80
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x7bf97
jmp 0x7bfb6
leaq 0x512f(%rip), %rdi      # 0x810cd
leaq 0x5090(%rip), %rsi      # 0x81035
movl $0xe3, %edx
leaq 0x5141(%rip), %rcx      # 0x810f2
callq 0xe440
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7bbd0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
ja 0x7bfd5
jmp 0x7bff4
leaq 0x5153(%rip), %rdi      # 0x8112f
leaq 0x5052(%rip), %rsi      # 0x81035
movl $0xe4, %edx
leaq 0x5103(%rip), %rcx      # 0x810f2
callq 0xe440
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7c010
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.c
// Function: advance_wpos
void
advance_wpos(gdc_circular_queue *q, size_t len)
{
	size_t wp = atomic_load_explicit(&q->wpos, memory_order_relaxed);
	wp = (wp + len) % gdc_circular_queue_capacity(q);
	memory_order mo = q->properties.sync ? memory_order_release : memory_order_relaxed;
	atomic_store_explicit(&q->wpos, wp, mo);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7ba80
movq %rax, %rcx
movq -0x48(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x88(%rax), %eax
testl %eax, %eax
setne %al
movzbl %al, %ecx
movl %ecx, %eax
leal (%rax,%rax,2), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x30(%rbp)
subl $0x3, %eax
je 0x7c0ae
jmp 0x7c097
movl -0x34(%rbp), %eax
subl $0x5, %eax
je 0x7c0bb
jmp 0x7c0a1
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x7c0c6
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x7c0c6
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
xchgq %rax, (%rcx)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1e, %edi
callq 0xe430
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x7c2ab
movq $0x0, -0x8(%rbp)
jmp 0x7c31b
cmpq $0x0, -0x18(%rbp)
jle 0x7c2b4
jmp 0x7c2d3
leaq 0x4f5d(%rip), %rdi      # 0x81218
leaq 0x4f64(%rip), %rsi      # 0x81226
movl $0x30, %edx
leaq 0x4fb9(%rip), %rcx      # 0x81287
callq 0xe440
cmpq $0x0, -0x10(%rbp)
jne 0x7c2e4
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7c31b
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
subq $0x1, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq $0x1, %rcx
imulq -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x1, -0x30(%rbp)
movl -0x30(%rbp), %eax
lock
xaddl %eax, 0x39603(%rip)     # 0xb597c
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0xe940
movl %eax, -0x38(%rbp)
leaq -0x60(%rbp), %rdi
movl -0x38(%rbp), %edx
movl -0x2c(%rbp), %ecx
leaq 0x4e71(%rip), %rsi      # 0x8120c
movb $0x0, %al
callq 0xe0e0
leaq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x7c0d0
cmpl $-0x1, %eax
jne 0x7c3c9
movq $0x0, -0x8(%rbp)
jmp 0x7c3e7
leaq -0x60(%rbp), %rdi
callq 0x7c400
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x7c330
movq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x7c753
movq -0x10(%rbp), %rdi
callq 0x7ba80
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7c280
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq -0x18(%rbp), %rsi
callq 0xe360
movl %eax, -0x4(%rbp)
jmp 0x7c75a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: sotrteacher[P]1MM1INTRO/20190820_1MM1_INTRO/porvalor_porreferencia.c
// Function: intercambiar
void intercambiar(float A,float B)
{
  float tmp;
  tmp=A;
  A=B;
  B=tmp;
  mostrar1(A,B);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss -0x4(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
leaq 0xe95(%rip), %rdi       # 0x200c
leaq 0xea0(%rip), %rsi       # 0x201e
movb $0x0, %al
callq 0x1030
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xe7c(%rip), %rdi       # 0x2011
movb $0x1, %al
callq 0x1030
leaq 0xe69(%rip), %rdi       # 0x200c
leaq 0xe77(%rip), %rsi       # 0x2021
movb $0x0, %al
callq 0x1030
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xe50(%rip), %rdi       # 0x2011
movb $0x1, %al
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movss -0x14(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
leaq 0xdfb(%rip), %rdi       # 0x200c
leaq 0xe05(%rip), %rsi       # 0x201d
movb $0x0, %al
callq 0x1030
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xddf(%rip), %rdi       # 0x2011
movb $0x1, %al
callq 0x1030
leaq 0xdcc(%rip), %rdi       # 0x200c
leaq 0xdd9(%rip), %rsi       # 0x2020
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xdb0(%rip), %rdi       # 0x2011
movb $0x1, %al
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss 0xd7a(%rip), %xmm0      # 0x2008
movss %xmm0, -0x14(%rbp)
movss 0xd69(%rip), %xmm0      # 0x2004
movss %xmm0, -0x18(%rbp)
leaq 0xd7c(%rip), %rdi       # 0x2023
movb $0x0, %al
callq 0x1030
leaq 0xd78(%rip), %rdi       # 0x202d
leaq 0x2d74(%rip), %rsi      # 0x4030
leaq 0x2d72(%rip), %rdx      # 0x4035
leaq 0x2d6e(%rip), %rcx      # 0x4038
movb $0x0, %al
callq 0x1030
leaq 0xd5e(%rip), %rdi       # 0x2036
movb $0x0, %al
callq 0x1030
leaq 0xd26(%rip), %rdi       # 0x200c
leaq 0xd51(%rip), %rsi       # 0x203e
movb $0x0, %al
callq 0x1030
movss -0x14(%rbp), %xmm0
callq 0x1440
leaq 0xd07(%rip), %rdi       # 0x200c
leaq 0xd34(%rip), %rsi       # 0x2040
movb $0x0, %al
callq 0x1030
movss -0x18(%rbp), %xmm0
callq 0x1440
leaq 0xd1e(%rip), %rdi       # 0x2042
movb $0x0, %al
callq 0x1030
leaq 0xd42(%rip), %rdi       # 0x2074
movb $0x0, %al
callq 0x1030
leaq 0xd36(%rip), %rdi       # 0x2076
movb $0x0, %al
callq 0x1030
movss -0x14(%rbp), %xmm0
movss -0x18(%rbp), %xmm1
callq 0x1140
leaq 0xcd9(%rip), %rdi       # 0x2036
movb $0x0, %al
callq 0x1030
leaq 0xca1(%rip), %rdi       # 0x200c
leaq 0xccc(%rip), %rsi       # 0x203e
movb $0x0, %al
callq 0x1030
movss -0x14(%rbp), %xmm0
callq 0x1440
leaq 0xc82(%rip), %rdi       # 0x200c
leaq 0xcaf(%rip), %rsi       # 0x2040
movb $0x0, %al
callq 0x1030
movss -0x18(%rbp), %xmm0
callq 0x1440
leaq 0xc99(%rip), %rdi       # 0x2042
movb $0x0, %al
callq 0x1030
leaq 0xcbd(%rip), %rdi       # 0x2074
movb $0x0, %al
callq 0x1030
leaq 0xcc0(%rip), %rdi       # 0x2085
movb $0x0, %al
callq 0x1030
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x11d0
leaq 0xc56(%rip), %rdi       # 0x2036
movb $0x0, %al
callq 0x1030
leaq 0xc1e(%rip), %rdi       # 0x200c
leaq 0xc49(%rip), %rsi       # 0x203e
movb $0x0, %al
callq 0x1030
movss -0x14(%rbp), %xmm0
callq 0x1440
leaq 0xbff(%rip), %rdi       # 0x200c
leaq 0xc2c(%rip), %rsi       # 0x2040
movb $0x0, %al
callq 0x1030
movss -0x18(%rbp), %xmm0
callq 0x1440
leaq 0xc16(%rip), %rdi       # 0x2042
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ctSkennerton[P]fxtract/util/./winstr.c
// Function: winstr
char *
winstr(char *tgt, char *pat)
{
    unsigned     len = strlen(pat);
    switch (len) {
    case  0: return tgt;
    case  1: return strchr( tgt,*pat);
    case  2: return winstr2(tgt, pat);
    case  3: return winstr3(tgt, pat);
    case  4: return winstr4(tgt, pat);
#   if __SIZEOF_SIZE_T__ == 8
    case  5: return winstr5(tgt, pat);
    case  6: return winstr6(tgt, pat);
    case  7: return winstr7(tgt, pat);
    case  8: return winstr8(tgt, pat);
#   endif
    default: return winstrm(tgt, pat, len);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30d0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x8, %rax
ja 0x43df
movq -0x28(%rbp), %rax
leaq 0x7cf0(%rip), %rcx      # 0xc018
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x43f3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movsbl (%rax), %esi
callq 0x30c0
movq %rax, -0x8(%rbp)
jmp 0x43f3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6e10
movq %rax, -0x8(%rbp)
jmp 0x43f3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6ea0
movq %rax, -0x8(%rbp)
jmp 0x43f3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6f40
movq %rax, -0x8(%rbp)
jmp 0x43f3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6fd0
movq %rax, -0x8(%rbp)
jmp 0x43f3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x70a0
movq %rax, -0x8(%rbp)
jmp 0x43f3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7170
movq %rax, -0x8(%rbp)
jmp 0x43f3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7240
movq %rax, -0x8(%rbp)
jmp 0x43f3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x72f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ctSkennerton[P]fxtract/util/./railgun7w.c
// Function: Railgun7w
char *
Railgun7w(char *pbTarget, int cbTarget, char *pbPattern, int cbPattern)
{
    return (char*)(
           cbPattern > cbTarget ? NULL
         : cbPattern < 3        ? NULL  //XXX dummy something up, even just "do cp = strchr(cp, pat[1]); while (cp && cp[-1] != pat[0]);"
         : cbPattern == 3       ? check3(  (byte*)pbTarget, (byte*)pbPattern, (uint)cbTarget)
         : cbTarget < 961       ? check4(  (byte*)pbTarget, (byte*)pbPattern, (uint)cbTarget, (uint)cbPattern)
         : cbPattern <= 22      ? bloom2(  (byte*)pbTarget, (byte*)pbPattern, (uint)cbTarget, (uint)cbPattern)
         : cbPattern <= 712     ? bloom4(  (byte*)pbTarget, (byte*)pbPattern, (uint)cbTarget, (uint)cbPattern)
                                : bloom12( (byte*)pbTarget, (byte*)pbPattern, (uint)cbTarget, (uint)cbPattern)
        );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x6339
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x640b
cmpl $0x3, -0x1c(%rbp)
jge 0x634a
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x6403
cmpl $0x3, -0x1c(%rbp)
jne 0x6369
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0x64b0
movq %rax, -0x38(%rbp)
jmp 0x63fb
cmpl $0x3c1, -0xc(%rbp)      # imm = 0x3C1
jge 0x638b
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x65a0
movq %rax, -0x40(%rbp)
jmp 0x63f3
cmpl $0x16, -0x1c(%rbp)
jg 0x63aa
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x6760
movq %rax, -0x48(%rbp)
jmp 0x63eb
cmpl $0x2c8, -0x1c(%rbp)     # imm = 0x2C8
jg 0x63cc
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x68c0
movq %rax, -0x50(%rbp)
jmp 0x63e3
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x6a10
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ctSkennerton[P]fxtract/util/./railgun7w.c
// Function: check3
static byte *
check3(byte *pbTarget, byte *pbPattern, uint cbTarget)
{
    byte *pbTargetMax = pbTarget + cbTarget - 3, A = pbPattern[0];
    uint ulHashPattern = ((uint)A << 8) + pbPattern[2];
    do { 
        if (ulHashPattern == ((uint)pbTarget[0] << 8) + pbTarget[2]
                && pbPattern[1] == pbTarget[1])
            return pbTarget;

        pbTarget += pbTarget[1] == A ? 0 : pbTarget[2] == A ? 1 : 2;
    } while (++pbTarget <= pbTargetMax);

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addq %rcx, %rax
addq $-0x3, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
shll $0x8, %eax
movq -0x18(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
shll $0x8, %ecx
movq -0x10(%rbp), %rdx
movzbl 0x2(%rdx), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jne 0x6527
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
cmpl %ecx, %eax
jne 0x6527
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x658b
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movzbl -0x29(%rbp), %ecx
cmpl %ecx, %eax
jne 0x653e
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x655c
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %edx
movzbl -0x29(%rbp), %esi
movl $0x2, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
cmpq -0x28(%rbp), %rax
jbe 0x64ee
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ctSkennerton[P]fxtract/util/./railgun7w.c
// Function: bloom2
static byte *
bloom2(byte *pbTarget, byte *pbPattern, uint cbTarget, uint cbPattern)
{
    uint i, skip, ulHashPattern = *(uint*) pbPattern;  // First four bytes
    byte filter[256 * 256] = {}; //XXX Let compiler figure out fastest way to zero this out.
    for (i = 0; i < cbPattern - 1; i++)
        filter[*(uint16_t*)(pbPattern + i)] = 1;

    for (i = 0; i <= cbTarget - cbPattern; i += skip) {
        if (!filter[*(uint16_t*) &pbTarget[i + cbPattern - 2]])    // Test YZ
            skip = cbPattern - 1;
        else if (2 > filter[*(uint16_t*) &pbTarget[i + cbPattern - 4]] // X+Y<2 vs !(X|Y) 
                   + filter[*(uint16_t*) &pbTarget[i + cbPattern - 3]]) // Test XY
            skip = cbPattern - 3;
        else if (*(uint*)&pbTarget[i] == ulHashPattern && !intdiff(pbTarget + i, pbPattern, cbPattern))
            return pbTarget + i;
        else skip = 1;
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10030, %rsp          # imm = 0x10030
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
leaq -0x10030(%rbp), %rdi
xorl %esi, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0x3110
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x67c7
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movzwl (%rax,%rcx), %eax
movb $0x1, -0x10030(%rbp,%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x679c
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl -0x20(%rbp), %ecx
cmpl %ecx, %eax
ja 0x68ab
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl -0x20(%rbp), %ecx
subl $0x2, %ecx
movl %ecx, %ecx
movzwl (%rax,%rcx), %eax
cmpb $0x0, -0x10030(%rbp,%rax)
jne 0x680a
movl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x689b
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl -0x20(%rbp), %ecx
subl $0x4, %ecx
movl %ecx, %ecx
movzwl (%rax,%rcx), %eax
movzbl -0x10030(%rbp,%rax), %ecx
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %edx
addl -0x20(%rbp), %edx
subl $0x3, %edx
movl %edx, %edx
movzwl (%rax,%rdx), %eax
movzbl -0x10030(%rbp,%rax), %eax
addl %eax, %ecx
movl $0x2, %eax
cmpl %ecx, %eax
jle 0x6856
movl -0x20(%rbp), %eax
subl $0x3, %eax
movl %eax, -0x28(%rbp)
jmp 0x6899
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movl (%rax,%rcx), %eax
cmpl -0x2c(%rbp), %eax
jne 0x6890
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %edx
callq 0x6c90
cmpl $0x0, %eax
jne 0x6890
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x68b3
movl $0x1, -0x28(%rbp)
jmp 0x6899
jmp 0x689b
jmp 0x689d
movl -0x28(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x67ce
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10030, %rsp          # imm = 0x10030
popq %rbp
retq
// File: ctSkennerton[P]fxtract/util/./railgun7w.c
// Function: bloom4
static byte *
bloom4(byte *pbTarget, byte *pbPattern, uint cbTarget, uint cbPattern)
{
    uint i, skip, ulHashPattern = *(uint*)pbPattern;  // First four bytes
    byte filter[256 * 256] = {};

    for (i = 0; i < cbPattern - 3; i++)
        filter[ foldp(pbPattern + i) ] = 1;

    for (i = 0; i <= cbTarget - cbPattern; i += skip) {
        if (!filter[ foldp(pbTarget + cbPattern - 4) ])
            skip = cbPattern - 3;
        else if (!filter[ foldp(pbTarget + i + cbPattern - 8) ])
            skip = cbPattern - 7;
        else if (*(uint*)&pbTarget[i] == ulHashPattern && !intdiff(pbTarget + i, pbPattern, cbPattern))
            return pbTarget + i;
        else skip = 1;
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10030, %rsp          # imm = 0x10030
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
leaq -0x10030(%rbp), %rdi
xorl %esi, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0x3110
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x20(%rbp), %ecx
subl $0x3, %ecx
cmpl %ecx, %eax
jae 0x692d
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
addq %rax, %rdi
callq 0x6cf0
movl %eax, %eax
movb $0x1, -0x10030(%rbp,%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x68fc
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl -0x20(%rbp), %ecx
cmpl %ecx, %eax
ja 0x69f4
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
addq %rax, %rdi
addq $-0x4, %rdi
callq 0x6cf0
movl %eax, %eax
cmpb $0x0, -0x10030(%rbp,%rax)
jne 0x696f
movl -0x20(%rbp), %eax
subl $0x3, %eax
movl %eax, -0x28(%rbp)
jmp 0x69e4
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
addq %rax, %rdi
movl -0x20(%rbp), %eax
addq %rax, %rdi
addq $-0x8, %rdi
callq 0x6cf0
movl %eax, %eax
cmpb $0x0, -0x10030(%rbp,%rax)
jne 0x699f
movl -0x20(%rbp), %eax
subl $0x7, %eax
movl %eax, -0x28(%rbp)
jmp 0x69e2
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
movl (%rax,%rcx), %eax
cmpl -0x2c(%rbp), %eax
jne 0x69d9
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %edx
callq 0x6c90
cmpl $0x0, %eax
jne 0x69d9
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x69fc
movl $0x1, -0x28(%rbp)
jmp 0x69e2
jmp 0x69e4
jmp 0x69e6
movl -0x28(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x6934
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10030, %rsp          # imm = 0x10030
popq %rbp
retq
nopl (%rax)
// File: ctSkennerton[P]fxtract/util/./railgun7w.c
// Function: intdiff
static inline uint
intdiff(byte *pbOne, byte *pbTwo, uint cbLen)
{
    int i = cbLen;
    while ((i -= sizeof(uint)) > 0)
         if (*(uint*)&pbOne[i] != *(uint*)&pbTwo[i]) return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movslq -0x20(%rbp), %rax
subq $0x4, %rax
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
jle 0x6cd8
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
cmpl (%rcx,%rdx), %eax
je 0x6cd6
movl $0x1, -0x4(%rbp)
jmp 0x6cdf
jmp 0x6ca5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ctSkennerton[P]fxtract/util/./winstr.c
// Function: winstr2
static char *
winstr2(char *tgt, char pat[2])
{
    uint16_t head = *(uint16_t*)pat, wind = *(uint16_t*)tgt;
    if (!(uint8_t)wind) return NULL;
    while (1) {
        if (!(wind & 0xFF00)) return NULL;
        if (wind == head) return tgt;
        wind = *(uint16_t*)++tgt;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movw (%rax), %ax
movw %ax, -0x1a(%rbp)
movq -0x10(%rbp), %rax
movw (%rax), %ax
movw %ax, -0x1c(%rbp)
movw -0x1c(%rbp), %ax
cmpb $0x0, %al
jne 0x6e44
movq $0x0, -0x8(%rbp)
jmp 0x6e8d
jmp 0x6e46
movzwl -0x1c(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
cmpl $0x0, %eax
jne 0x6e5e
movq $0x0, -0x8(%rbp)
jmp 0x6e8d
movzwl -0x1c(%rbp), %eax
movzwl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jne 0x6e74
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6e8d
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movw 0x1(%rax), %ax
movw %ax, -0x1c(%rbp)
jmp 0x6e46
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ctSkennerton[P]fxtract/util/./winstr.c
// Function: winstrm
static char *
winstrm(char *tgt, char *pat, int len)
{
    UINT head = *(UINT*)pat, wind = *(UINT*)tgt;
    if ((wind - x01) & ~wind & x80)
        return NULL;

    while (1) {
        if (head == wind && !memdiff(tgt+sizeof(UINT), pat+sizeof(UINT), len-sizeof(UINT)))
            return tgt;
        wind = *(UINT*)++tgt;
        if (!(wind & SHLB(0xFFL, sizeof(UINT) - 1)))
            return NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movabsq $0x101010101010101, %rcx # imm = 0x101010101010101
subq %rcx, %rax
movq -0x30(%rbp), %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movabsq $-0x7f7f7f7f7f7f7f80, %rcx # imm = 0x8080808080808080
andq %rcx, %rax
cmpq $0x0, %rax
je 0x7352
movq $0x0, -0x8(%rbp)
jmp 0x73c3
jmp 0x7354
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x738c
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
movslq -0x1c(%rbp), %rax
subq $0x8, %rax
movl %eax, %edx
callq 0x73d0
cmpl $0x0, %eax
jne 0x738c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x73c3
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movq 0x1(%rax), %rax
movq %rax, -0x30(%rbp)
movabsq $-0x100000000000000, %rax # imm = 0xFF00000000000000
andq -0x30(%rbp), %rax
cmpq $0x0, %rax
jne 0x73c1
movq $0x0, -0x8(%rbp)
jmp 0x73c3
jmp 0x7354
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)