LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: SNUCSE-CTA[P]GI/src/backtrack.cpp
// Function: Backtrack::binarySearch(std::vector<int, std::allocator<int>>&, int)
int32_t Backtrack::binarySearch(vector<int32_t>& aVector, int32_t aValue)
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	if( aVector.size() == 0 )
		return -1;

	int32_t l, r, m;
	int32_t size = aVector.size();

	//do linear search when size is small
	if( size < 10 ) { 
		for(l = 0; l < size; ++l) {
			if( aVector[l] == aValue )
				return l;
		}
		return -1;
	}

	//binary search
	l = 0;
	r = size - 1;
	while( l <= r ) {
		m = l + (r - l)/2;
		if( aVector[m] < aValue )
			l = m + 1;
		else if( aVector[m] > aValue )
			r = m - 1;
		else //aVector[m] == aValue
			return m;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10bf0
cmpq $0x0, %rax
jne 0xf2ae
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf38e
movq -0x18(%rbp), %rdi
callq 0x10bf0
movl %eax, -0x2c(%rbp)
cmpl $0xa, -0x2c(%rbp)
jge 0xf307
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0xf2fb
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x10da0
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0xf2ee
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xf38e
jmp 0xf2f0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xf2c7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf38e
movl $0x0, -0x20(%rbp)
movl -0x2c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jg 0xf387
movl -0x20(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x24(%rbp), %eax
subl -0x20(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x30(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x10da0
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0xf35c
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xf385
movq -0x18(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x10da0
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jle 0xf37b
movl -0x28(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xf383
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xf38e
jmp 0xf385
jmp 0xf317
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: SNUCSE-CTA[P]GI/src/heap.cpp
// Function: Heap::Heap(int)
Heap::Heap(int32_t aSize)
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	heap = new int32_t[aSize];
	locate = new int32_t[aSize];
	memset(locate, -1, sizeof(int32_t) * aSize);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
movslq -0xc(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movslq -0xc(%rbp), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rdi
movslq -0xc(%rbp), %rdx
shlq $0x2, %rdx
movl $0xff, %esi
callq 0x3110
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: SNUCSE-CTA[P]GI/src/heap.cpp
// Function: Heap::~Heap()
Heap::~Heap()
{
	if( heap != NULL) {
		delete[] heap;
		heap = NULL;
	}
	if( locate != NULL) {
		delete[] locate;
		locate = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x1373f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x13734
movq -0x18(%rbp), %rdi
callq 0x3280
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x13771
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x13765
movq -0x20(%rbp), %rdi
callq 0x3280
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: SNUCSE-CTA[P]GI/src/heap.cpp
// Function: Heap::minHeapify(int*, int)
void Heap::minHeapify(int32_t* aValue, int32_t aIndex)
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	int32_t l, r, s, t;
	int32_t i = aIndex;

	while(true) {
		s = i;	//smaller one's index
		l = LEFT(i);	//left child's index
		r = RIGHT(i);	//right child's index
		if( l <= size && aValue[heap[l]] < aValue[heap[s]] )
			s = l;
		if( r <= size && aValue[heap[r]] < aValue[heap[s]] )
			s = r;
		if( s != i ) { // if one of the children is smaller than i
			t = heap[s];
			heap[s] = heap[i];
			heap[i] = t;

			locate[ heap[s] ] = s;
			locate[ heap[i] ] = i;

			i = s;
		}
		else {
			break;
		}
	} //while(true)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movl -0x28(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x28(%rbp), %eax
shll %eax
movl %eax, -0x18(%rbp)
movl -0x28(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl 0x10(%rcx), %eax
jg 0x137f2
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rdx), %rcx
movslq -0x18(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movq (%rdx), %rdx
movslq -0x20(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x137f2
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x10(%rcx), %eax
jg 0x1382e
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rdx), %rcx
movslq -0x1c(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movq (%rdx), %rdx
movslq -0x20(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x1382e
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x28(%rbp), %eax
je 0x1389a
movq -0x30(%rbp), %rcx
movq (%rcx), %rax
movslq -0x20(%rbp), %rdx
movl (%rax,%rdx,4), %eax
movl %eax, -0x24(%rbp)
movq (%rcx), %rax
movslq -0x28(%rbp), %rdx
movl (%rax,%rdx,4), %esi
movq (%rcx), %rax
movslq -0x20(%rbp), %rdx
movl %esi, (%rax,%rdx,4)
movl -0x24(%rbp), %esi
movq (%rcx), %rax
movslq -0x28(%rbp), %rdx
movl %esi, (%rax,%rdx,4)
movl -0x20(%rbp), %esi
movq 0x8(%rcx), %rax
movq (%rcx), %rdx
movslq -0x20(%rbp), %rdi
movslq (%rdx,%rdi,4), %rdx
movl %esi, (%rax,%rdx,4)
movl -0x28(%rbp), %edx
movq 0x8(%rcx), %rax
movq (%rcx), %rcx
movslq -0x28(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x1389c
jmp 0x138a1
jmp 0x1379d
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: SNUCSE-CTA[P]GI/src/heap.cpp
// Function: Heap::insert(int*, int)
void Heap::insert(int32_t* aValue, int32_t aVertex)
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	int32_t i, p, t;
	++size;
	heap[size] = aVertex;
	locate[aVertex] = size;
	i = size;
	while( i > 1 ) {
		p = PARENT(i);
		if( aValue[heap[p]] > aValue[heap[i]] ) {
			t = heap[p];
			heap[p] = heap[i];
			heap[i] = t;

			locate[ heap[p] ] = p;
			locate[ heap[i] ] = i;

			i = p;
		}
		else {
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movl -0x14(%rbp), %esi
movq (%rax), %rcx
movslq 0x10(%rax), %rdx
movl %esi, (%rcx,%rdx,4)
movl 0x10(%rax), %esi
movq 0x8(%rax), %rcx
movslq -0x14(%rbp), %rdx
movl %esi, (%rcx,%rdx,4)
movl 0x10(%rax), %eax
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
jle 0x139e8
movq -0x28(%rbp), %rdx
movl -0x18(%rbp), %eax
sarl %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rdx), %rcx
movslq -0x1c(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movq (%rdx), %rdx
movslq -0x18(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x139e1
movq -0x28(%rbp), %rcx
movq (%rcx), %rax
movslq -0x1c(%rbp), %rdx
movl (%rax,%rdx,4), %eax
movl %eax, -0x20(%rbp)
movq (%rcx), %rax
movslq -0x18(%rbp), %rdx
movl (%rax,%rdx,4), %esi
movq (%rcx), %rax
movslq -0x1c(%rbp), %rdx
movl %esi, (%rax,%rdx,4)
movl -0x20(%rbp), %esi
movq (%rcx), %rax
movslq -0x18(%rbp), %rdx
movl %esi, (%rax,%rdx,4)
movl -0x1c(%rbp), %esi
movq 0x8(%rcx), %rax
movq (%rcx), %rdx
movslq -0x1c(%rbp), %rdi
movslq (%rdx,%rdi,4), %rdx
movl %esi, (%rax,%rdx,4)
movl -0x18(%rbp), %edx
movq 0x8(%rcx), %rax
movq (%rcx), %rcx
movslq -0x18(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x139e3
jmp 0x139e8
jmp 0x13941
popq %rbp
retq
nopw (%rax,%rax)
// File: SNUCSE-CTA[P]GI/src/heap.cpp
// Function: Heap::erase(int*, int)
void Heap::erase(int32_t* aValue, int32_t aVertex)
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	int32_t i = locate[aVertex];
	if( i < 0 )
		return;
	
	locate[aVertex] = -1;
	heap[i] = heap[size];
	locate[ heap[i] ] = i;
	--size;
	if( size > 0 )
		minHeapify(aValue, i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x13a21
jmp 0x13a7c
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0x14(%rbp), %rdx
movl $0xffffffff, (%rcx,%rdx,4) # imm = 0xFFFFFFFF
movq (%rax), %rcx
movslq 0x10(%rax), %rdx
movl (%rcx,%rdx,4), %esi
movq (%rax), %rcx
movslq -0x18(%rbp), %rdx
movl %esi, (%rcx,%rdx,4)
movl -0x18(%rbp), %esi
movq 0x8(%rax), %rcx
movq (%rax), %rdx
movslq -0x18(%rbp), %rdi
movslq (%rdx,%rdi,4), %rdx
movl %esi, (%rcx,%rdx,4)
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
cmpl $0x0, 0x10(%rax)
jle 0x13a7c
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x13780
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: SNUCSE-CTA[P]GI/src/heap.cpp
// Function: Heap::extractMin(int*)
int32_t Heap::extractMin(int32_t* aValue)
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	if( size < 1 ) {
		return -1;
	}
	
	int32_t min = heap[1];
	locate[min] = -1;
	heap[1] = heap[size];
	locate[ heap[1] ] = 1;
	--size;

	if( size > 0 )
		minHeapify(aValue, 1);
	
	return min;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x1, 0x10(%rax)
jge 0x13ab7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x13b1c
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, -0x1c(%rbp)
movq 0x8(%rax), %rcx
movslq -0x1c(%rbp), %rdx
movl $0xffffffff, (%rcx,%rdx,4) # imm = 0xFFFFFFFF
movq (%rax), %rcx
movslq 0x10(%rax), %rdx
movl (%rcx,%rdx,4), %edx
movq (%rax), %rcx
movl %edx, 0x4(%rcx)
movq 0x8(%rax), %rcx
movq (%rax), %rdx
movslq 0x4(%rdx), %rdx
movl $0x1, (%rcx,%rdx,4)
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
cmpl $0x0, 0x10(%rax)
jle 0x13b16
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x13780
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: SNUCSE-CTA[P]GI/src/refine.cpp
// Function: Refinement::Refinement(Context&)
Refinement::Refinement(Context& aContext) 
{
	global_memory = &(aContext.global_memory);
	markCell = aContext.markCell;
	markNode = aContext.markNode;
	global_mark = aContext.global_mark;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0x14(%rax)
movl $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movl $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x38(%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x48(%rax)
movq $0x0, 0x50(%rax)
movq $0x0, 0x58(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x68(%rax)
movq $0x0, 0x70(%rax)
movq $0x0, 0x78(%rax)
movl $0x0, 0x80(%rax)
movq -0x10(%rbp), %rcx
addq $0x18, %rcx
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x70(%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x78(%rax)
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x80(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: SNUCSE-CTA[P]GI/src/refine.cpp
// Function: Refinement::~Refinement()
Refinement::~Refinement()
{
	if (stableColoring != NULL) {
		delete stableColoring;
		stableColoring = NULL;
	}
	clearWorkspace();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x13c5d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x13c52
movq -0x18(%rbp), %rdi
callq 0x17b40
movq -0x18(%rbp), %rdi
movl $0x28, %esi
callq 0x31d0
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x13c80
jmp 0x13c68
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x4400
nopw %cs:(%rax,%rax)
// File: SNUCSE-CTA[P]GI/src/refine.cpp
// Function: Refinement::clearWorkspace()
void Refinement::clearWorkspace()
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	if (cellStack != NULL) {
		global_memory->returnLLArray(cellStack, n2);
		cellStack = NULL;
	}
	if (neighCount != NULL) {
		global_memory->returnLLArray(neighCount, n2);
		neighCount = NULL;
	}
	if (visitCell != NULL) {
		global_memory->returnLLArray(visitCell, n2);
		visitCell = NULL;
	}
	if (visitNode != NULL) {
		global_memory->returnLLArray(visitNode, n2);
		visitNode = NULL;
	}
	if (numVisitNode != NULL) {
		global_memory->returnLLArray(numVisitNode, n2);
		numVisitNode = NULL;
	}
	if (splitCell != NULL) {
		global_memory->returnLLArray(splitCell, n2);
		splitCell = NULL;
	}
	if (splitCount != NULL) {
		global_memory->returnLLArray(splitCount, n2);
		splitCount = NULL;
	}
	if (splitPos != NULL) {
		global_memory->returnLLArray(splitPos, n2);
		splitPos = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x20(%rax)
je 0x13cbb
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movq 0x20(%rax), %rsi
movl 0x10(%rax), %edx
callq 0x7a30
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x13ce6
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movq 0x30(%rax), %rsi
movl 0x10(%rax), %edx
callq 0x7a30
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x13d11
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movq 0x38(%rax), %rsi
movl 0x10(%rax), %edx
callq 0x7a30
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x13d3c
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movq 0x40(%rax), %rsi
movl 0x10(%rax), %edx
callq 0x7a30
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x13d67
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movq 0x48(%rax), %rsi
movl 0x10(%rax), %edx
callq 0x7a30
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x13d92
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movq 0x50(%rax), %rsi
movl 0x10(%rax), %edx
callq 0x7a30
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x13dbd
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movq 0x58(%rax), %rsi
movl 0x10(%rax), %edx
callq 0x7a30
movq -0x10(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x13de8
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movq 0x60(%rax), %rsi
movl 0x10(%rax), %edx
callq 0x7a30
movq -0x10(%rbp), %rax
movq $0x0, 0x60(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: SNUCSE-CTA[P]GI/src/refine.cpp
// Function: Refinement::run(Graph*, Graph*)
bool Refinement::run(Graph* aG1, Graph* aG2)
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	n = aG1->numNode;
	e = aG1->numEdge;
	n2 = n * 2;
	e2 = e * 2;

	if (stableColoring != NULL) {
		delete stableColoring;
	}
	stableColoring = new Coloring(n2);
	// Allocate workspace variables
	initWorkspace();

	// Initial coloring
	bool ret = colorByDegreeAndLabel(stableColoring, aG1, aG2);
	if (ret) {
		// Process coreness-1 vertices
		numTreeNode = prepCoreOne(stableColoring, aG1, aG2);

		// Refine coloring
		ret = refine(stableColoring, aG1, aG2);
	}

	// Free workspace variables
	clearWorkspace();

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x14(%rax)
movl 0xc(%rax), %ecx
shll %ecx
movl %ecx, 0x10(%rax)
movl 0x14(%rax), %ecx
shll %ecx
movl %ecx, 0x18(%rax)
cmpq $0x0, (%rax)
je 0x13e60
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x13e5e
movq -0x38(%rbp), %rdi
callq 0x17b40
movq -0x38(%rbp), %rdi
movl $0x28, %esi
callq 0x31d0
jmp 0x13e60
movl $0x28, %edi
callq 0x31c0
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x40(%rbp)
movl 0x10(%rax), %esi
callq 0x179a0
jmp 0x13e82
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, (%rdi)
callq 0x13f20
movq -0x30(%rbp), %rdi
movq (%rdi), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x14010
andb $0x1, %al
movb %al, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
je 0x13eff
movq -0x30(%rbp), %rdi
movq (%rdi), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x14330
movq -0x30(%rbp), %rdi
movl %eax, 0x8(%rdi)
movq (%rdi), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x15320
andb $0x1, %al
movb %al, -0x25(%rbp)
jmp 0x13eff
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x28, %esi
callq 0x31d0
jmp 0x13f13
movq -0x30(%rbp), %rdi
callq 0x13c80
movb -0x25(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3370
nopl (%rax)
// File: SNUCSE-CTA[P]GI/src/refine.cpp
// Function: Refinement::initWorkspace()
void Refinement::initWorkspace()
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	clearWorkspace(); //avoid double allocation

	cellStack = global_memory->getLLArray(n2);
	stackSize = 0;
	neighCount = global_memory->getLLArray(n2);
	visitCell = global_memory->getLLArray(n2);
	visitNode = global_memory->getLLArray(n2);
	numVisitNode = global_memory->getLLArray(n2);
	splitCell = global_memory->getLLArray(n2);
	splitCount = global_memory->getLLArray(n2);
	splitPos = global_memory->getLLArray(n2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x13c80
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movl 0x10(%rax), %esi
callq 0x77d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, 0x28(%rax)
movq 0x68(%rax), %rdi
movl 0x10(%rax), %esi
callq 0x77d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq 0x68(%rax), %rdi
movl 0x10(%rax), %esi
callq 0x77d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq 0x68(%rax), %rdi
movl 0x10(%rax), %esi
callq 0x77d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq 0x68(%rax), %rdi
movl 0x10(%rax), %esi
callq 0x77d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq 0x68(%rax), %rdi
movl 0x10(%rax), %esi
callq 0x77d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq 0x68(%rax), %rdi
movl 0x10(%rax), %esi
callq 0x77d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq 0x68(%rax), %rdi
movl 0x10(%rax), %esi
callq 0x77d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: SNUCSE-CTA[P]GI/src/refine.cpp
// Function: Refinement::checkColoring(Coloring*)
bool Refinement::checkColoring(Coloring* coloring)
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	for (int32_t i = 0; i < coloring->numNode; i += coloring->cellSize[i]) {
		int32_t acc = 0;
		for (int32_t j = 0; j < coloring->cellSize[i]; ++j) {
			acc += (coloring->perm[i+j] < n) ? 1 : -1;
		}

		if (acc != 0) return false;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x166df
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x166b7
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x1c(%rbp), %edx
addl -0x24(%rbp), %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %edx
movl 0xc(%rax), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpl %esi, %edx
cmovll %ecx, %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x16668
cmpl $0x0, -0x20(%rbp)
je 0x166c3
movb $0x0, -0x1(%rbp)
jmp 0x166e3
jmp 0x166c5
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x1664b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: SNUCSE-CTA[P]GI/src/refine.cpp
// Function: Refinement::selectFromStack(Coloring*)
int32_t Refinement::selectFromStack(Coloring* coloring)
{
	int32_t ret = stackSize - 1;
	int32_t idx = stackSize - 2;
	while (idx >= 0) {
		if (coloring->cellSize[cellStack[idx]] < coloring->cellSize[cellStack[ret]]) {
			ret = idx;
		}

		if (coloring->cellSize[cellStack[ret]] == 2 || idx < stackSize - 13) {
			break;
		}

		--idx;
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x28(%rax), %ecx
subl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movl 0x28(%rax), %eax
subl $0x2, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x16802
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rdx), %rcx
movslq -0x18(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq 0x20(%rdx), %rdx
movslq -0x14(%rbp), %rsi
movslq (%rdx,%rsi,4), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x167c6
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
cmpl $0x2, (%rax,%rcx,4)
je 0x167f5
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
movl 0x28(%rcx), %ecx
subl $0xd, %ecx
cmpl %ecx, %eax
jge 0x167f7
jmp 0x16802
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x16786
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: SNUCSE-CTA[P]GI/src/coloring.cpp
// Function: Coloring::init(int)
void Coloring::init(int32_t aNumNode)
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	numNode = aNumNode;
	numCell = 1;

	color = new int32_t[numNode];
	perm = new int32_t[numNode];
	inv = new int32_t[numNode];
	cellSize = new int32_t[numNode];

	for (int32_t i = 0; i < numNode; ++i) {
		color[i] = 0;
		perm[i] = inv[i] = i;
		cellSize[i] = 0;
	}
	cellSize[0] = numNode;

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl $0x1, 0x4(%rax)
movslq (%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movslq (%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movslq (%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movslq (%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl (%rcx), %eax
jge 0x17b27
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0x10(%rbp), %rdx
movl $0x0, (%rcx,%rdx,4)
movl -0x10(%rbp), %esi
movq 0x18(%rax), %rcx
movslq -0x10(%rbp), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x10(%rax), %rcx
movslq -0x10(%rbp), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x20(%rax), %rax
movslq -0x10(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x17ad6
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq 0x20(%rax), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: SNUCSE-CTA[P]GI/src/coloring.cpp
// Function: Coloring::clear()
void Coloring::clear()
{
	#ifdef DEBUG
	cout << __PRETTY_FUNCTION__ << endl;
	#endif

	if (color != NULL) {
		delete[] color;
		color = NULL;
	}
	if (perm != NULL) {
		delete[] perm;
		perm = NULL;
	}
	if (inv != NULL) {
		delete[] inv;
		inv = NULL;
	}
	if (cellSize != NULL) {
		delete[] cellSize;
		cellSize = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x17bb2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x17ba6
movq -0x18(%rbp), %rdi
callq 0x3280
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x17be4
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x17bd8
movq -0x20(%rbp), %rdi
callq 0x3280
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x17c16
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x17c0a
movq -0x28(%rbp), %rdi
callq 0x3280
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x17c48
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x17c3c
movq -0x30(%rbp), %rdi
callq 0x3280
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: tomfunkhouser[P]gaps/apps/msh2msh/msh2msh.cpp
// Function: ReadMesh(char const*)
static R3Mesh *
ReadMesh(const char *mesh_name)
{
  // Start statistics
  RNTime start_time;
  start_time.Read();

  // Allocate mesh
  R3Mesh *mesh = new R3Mesh();
  assert(mesh);

  // Read mesh from file
  if (!mesh->ReadFile(mesh_name)) {
    delete mesh;
    return NULL;
  }

  // Check if mesh is valid
  assert(mesh->IsValid());

  // Print statistics
  if (print_verbose) {
    printf("Read mesh ...\n");
    printf("  Time = %.2f seconds\n", start_time.Elapsed());
    printf("  # Faces = %d\n", mesh->NFaces());
    printf("  # Edges = %d\n", mesh->NEdges());
    printf("  # Vertices = %d\n", mesh->NVertices());
    fflush(stdout);
  }

  // Return success
  return mesh;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xc35d0
movq 0x10(%rsp), %rdi
callq 0x165f0
movl $0x138, %edi            # imm = 0x138
callq 0xf4a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
callq 0x32880
jmp 0x1427e
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq (%rdi), %rax
callq *0x180(%rax)
cmpl $0x0, %eax
jne 0x142eb
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x142bb
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x50(%rsp)
jmp 0x14385
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x138, %esi            # imm = 0x138
callq 0xf4b0
jmp 0x1438f
cmpl $0x0, 0x14cba2(%rip)    # 0x160e94
je 0x1437b
leaq 0x111f98(%rip), %rdi    # 0x126297
movb $0x0, %al
callq 0xf070
leaq 0x38(%rsp), %rdi
callq 0xc3690
leaq 0x111ffa(%rip), %rdi    # 0x126311
movb $0x1, %al
callq 0xf070
movq 0x30(%rsp), %rdi
callq 0x164b0
movl %eax, %esi
leaq 0x111f75(%rip), %rdi    # 0x1262a6
movb $0x0, %al
callq 0xf070
movq 0x30(%rsp), %rdi
callq 0x16610
movl %eax, %esi
leaq 0x111f6b(%rip), %rdi    # 0x1262b6
movb $0x0, %al
callq 0xf070
movq 0x30(%rsp), %rdi
callq 0x16630
movl %eax, %esi
leaq 0x111f61(%rip), %rdi    # 0x1262c6
movb $0x0, %al
callq 0xf070
movq 0x14bc1d(%rip), %rax    # 0x15ff90
movq (%rax), %rdi
callq 0xf5a0
movq 0x30(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0xf820
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/msh2msh/msh2msh.cpp
// Function: MergeList(gaps::R3Mesh*, char const*)
static int
MergeList(R3Mesh *mesh, const char *filename)
{
  // Open list file
  FILE *fp = fopen(filename, "r");
  if (!fp) {
    RNFail("Unable to open list %s\n", filename);
    return 0;
  }

  // Merge meshes from list
  char src_filename[4096];
  while (fscanf(fp, "%s", src_filename) == (unsigned int) 1) {
    // Read mesh
    R3Mesh src_mesh;
    if (!src_mesh.ReadFile(src_filename)) return 0;
    mesh->CreateCopy(src_mesh);
  }

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
subq $0x1188, %rsp           # imm = 0x1188
movq %rdi, 0x1178(%rsp)
movq %rsi, 0x1170(%rsp)
movq 0x1170(%rsp), %rdi
leaq 0x11620d(%rip), %rsi    # 0x12a5d3
callq 0xf5b0
movq %rax, 0x1168(%rsp)
cmpq $0x0, 0x1168(%rsp)
jne 0x14404
movq 0x1170(%rsp), %rsi
leaq 0x111eec(%rip), %rdi    # 0x1262d9
movb $0x0, %al
callq 0xc77f0
movl $0x0, 0x1184(%rsp)
jmp 0x144db
jmp 0x14406
movq 0x1168(%rsp), %rdi
leaq 0x160(%rsp), %rdx
leaq 0x113feb(%rip), %rsi    # 0x128408
movb $0x0, %al
callq 0xf8a0
cmpl $0x1, %eax
jne 0x144c3
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x32880
movq 0x8(%rsp), %rdi
leaq 0x160(%rsp), %rsi
callq 0x4a8e0
movl %eax, 0x14(%rsp)
jmp 0x14454
movl 0x14(%rsp), %eax
cmpl $0x0, %eax
jne 0x1448c
movl $0x0, 0x1184(%rsp)
movl $0x1, 0x18(%rsp)
jmp 0x144a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x33780
jmp 0x144ea
movq 0x1178(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x49570
jmp 0x144a0
movl $0x0, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x33780
movl 0x18(%rsp), %eax
testl %eax, %eax
je 0x144be
jmp 0x144bc
jmp 0x144db
jmp 0x14406
movq 0x1168(%rsp), %rdi
callq 0xf490
movl $0x1, 0x1184(%rsp)
movl 0x1184(%rsp), %eax
addq $0x1188, %rsp           # imm = 0x1188
retq
movq 0x20(%rsp), %rdi
callq 0xf820
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/msh2msh/msh2msh.cpp
// Function: WriteMatrix(gaps::R4Matrix const&, char const*)
static int
WriteMatrix(const R4Matrix& m, const char *filename)
{
  // Open file
  FILE *fp = fopen(filename, "w");
  if (!fp) {
    RNFail("Unable to open matrix file: %s\n", filename);
    return 0;
  }

  // Write matrix to file
  for (int i = 0; i < 4; i++) {
    for (int j = 0; j < 4; j++) {
      fprintf(fp, "%g ", m[i][j]);
    }
  }

  // Close file
  fclose(fp);

  // Return success
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x111c30(%rip), %rsi    # 0x127bda
callq 0xf5b0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x15fdc
movq 0x20(%rsp), %rsi
leaq 0x1102af(%rip), %rdi    # 0x126277
movb $0x0, %al
callq 0xc77f0
movl $0x0, 0x34(%rsp)
jmp 0x1605d
movl $0x0, 0x14(%rsp)
cmpl $0x4, 0x14(%rsp)
jge 0x1604b
movl $0x0, 0x10(%rsp)
cmpl $0x4, 0x10(%rsp)
jge 0x1603c
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x16fe0
movq 0x8(%rsp), %rdi
movslq 0x10(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x1103b6(%rip), %rsi    # 0x1263de
movb $0x1, %al
callq 0xf6c0
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x15ff3
jmp 0x1603e
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x15fe4
movq 0x18(%rsp), %rdi
callq 0xf490
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: syzcch[P]FEC_C_version/fec_rs.cpp
// Function: main
int main()
{

    const int NUM = 8;
    printf("starting");
//  rscode *rsItem = new rscode();

    //all original data is 8, checksum data is 3, data stripe length is 1024
    rscode *rsItem = new rscode(11,3,1024);
    int *err = new int[NUM];

    // 1 means fault data
    for(int i=0; i<NUM; i++)
    {
        err[i] = 0;
    }

    rsItem->setData();
    rsItem->encoding();
    rsItem->outputData();


    // testing 3 errors, error disk sequence number is 0,1,3
    err[0]=1;
    err[1]=1;
    err[3]=1;
    rsItem->setErrData(err);
    rsItem->decoding();
    rsItem->outputOrigin();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl $0x8, -0x8(%rbp)
leaq 0x2c97(%rip), %rdi      # 0x5004
xorl %eax, %eax
callq 0x2040
movl $0x30, %edi
callq 0x2100
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movl $0xb, %esi
movl $0x3, %edx
movl $0x400, %ecx            # imm = 0x400
callq 0x2470
jmp 0x239e
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x20, %edi
callq 0x2030
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x8, -0x2c(%rbp)
jge 0x23f7
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x23bb
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x30, %esi
callq 0x2110
jmp 0x245f
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
movq -0x28(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x28(%rbp), %rax
movl $0x1, 0xc(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x21d0
nopl (%rax,%rax)
// File: syzcch[P]FEC_C_version/./fec_rs.h
// Function: rscode::rscode(int, int, int)
rscode(int allnum, int rsnum, int dataLength)
    {
        allNum = allnum;
        rsNum = rsnum;
        num = allNum - rsNum;
        stripe_unit_size = dataLength;
        gf_already_setup = 0;

        // use allnum here, rs includes original data and redudant data
        rs = (char **) malloc(sizeof(char *)*allNum);
        for(int i=0; i<allNum; i++)
        {
            rs[i]=(char *) malloc(sizeof(char)*stripe_unit_size);
            memset(rs[i],0,stripe_unit_size);
        }
        inthis = new int[allNum];
        for(int i = 0; i < allNum; i++)
        {
            inthis[i] = 0;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x25b0
movq -0x28(%rbp), %rax
leaq 0x486b(%rip), %rcx      # 0x6d08
addq $0x10, %rcx
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x1c(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x24(%rax)
movl 0x1c(%rax), %ecx
subl 0x24(%rax), %ecx
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x20(%rax)
movl $0x0, 0x18(%rax)
movl 0x1c(%rax), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x2190
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jae 0x2538
movq -0x28(%rbp), %rax
movslq 0x20(%rax), %rdi
shlq $0x0, %rdi
callq 0x2190
movq %rax, %rsi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x18(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x10(%rax), %rcx
movslq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movslq 0x20(%rax), %rdx
xorl %esi, %esi
callq 0x2090
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x24e6
movq -0x28(%rbp), %rax
movl 0x1c(%rax), %eax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jae 0x259c
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2572
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: syzcch[P]FEC_C_version/./fec_rs.h
// Function: rscode::outputOrigin()
void outputOrigin()
    {

        printf("After decoding:");
        for(int i=0; i < num; i++)
        {
            printf("data:%d:  ",i);
            printf(rs[i]);
            printf("\n");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x21a2(%rip), %rdi      # 0x531d
movb $0x0, %al
callq 0x2040
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jae 0x31d6
movl -0xc(%rbp), %esi
leaq 0x218e(%rip), %rdi      # 0x532d
movb $0x0, %al
callq 0x2040
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movb $0x0, %al
callq 0x2040
leaq 0x1ec1(%rip), %rdi      # 0x5085
movb $0x0, %al
callq 0x2040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3189
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: syzcch[P]FEC_C_version/./fec_rs.h
// Function: rscode::outputData()
void outputData()
    {

        printf("The res:");
        for(int i = num; i < allNum; i++)
        {
            printf(rs[i]);
            printf("\n");
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x213d(%rip), %rdi      # 0x5338
movb $0x0, %al
callq 0x2040
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jae 0x3248
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movb $0x0, %al
callq 0x2040
leaq 0x1e4f(%rip), %rdi      # 0x5085
movb $0x0, %al
callq 0x2040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x320c
addq $0x20, %rsp
popq %rbp
retq
nop
// File: syzcch[P]FEC_C_version/./fec_rs.h
// Function: rscode::gf_single_divide(int, int)
int gf_single_divide(int a, int b)
    {
        int sum_j;
        gf_modar_setup();
        if (b == 0)
            return -1;
        if (a == 0)
            return 0;
        sum_j = B_TO_J[a] - B_TO_J[b];

        return (int) J_TO_B[sum_j];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3cd0
cmpl $0x0, -0x18(%rbp)
jne 0x386a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x38a9
cmpl $0x0, -0x14(%rbp)
jne 0x3879
movl $0x0, -0x4(%rbp)
jmp 0x38a9
movq 0x38b0(%rip), %rax      # 0x7130
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x38a2(%rip), %rcx      # 0x7130
movslq -0x18(%rbp), %rdx
subl (%rcx,%rdx,4), %eax
movl %eax, -0x1c(%rbp)
movq 0x3899(%rip), %rax      # 0x7138
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: syzcch[P]FEC_C_version/./fec_rs.h
// Function: rscode::gf_mult_region(void*, int, int)
void gf_mult_region(void *region, int size, int factor)
    {
        int sum_j;
        int flog;
        unsigned char *r;
        int sz;
        int r_cache;

        gf_modar_setup();

        if (factor == 1)
            return;
        if (factor == 0)
        {
            (void) memset(region, 0, size);
            return;
        }

        flog = B_TO_J[factor];
        sz = size / sizeof(unsigned char);
        r = ((unsigned char *) region) + sz;

        while (r != region)
        {
            r--;
            r_cache = *r;
            if (r_cache != 0)
            {
                sum_j = (int) (B_TO_J[r_cache] + flog);

                *r = J_TO_B[sum_j];
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3cd0
cmpl $0x1, -0x18(%rbp)
jne 0x38ea
jmp 0x397e
cmpl $0x0, -0x18(%rbp)
jne 0x3901
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rdx
xorl %esi, %esi
callq 0x2090
jmp 0x397e
movq 0x3828(%rip), %rax      # 0x7130
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movslq -0x14(%rbp), %rax
shrq $0x0, %rax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x397e
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0x397c
movq 0x37d7(%rip), %rax      # 0x7130
movslq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq 0x37cb(%rip), %rax      # 0x7138
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
jmp 0x392c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: syzcch[P]FEC_C_version/./fec_rs.h
// Function: rscode::gf_make_vandermonde(int, int)
int *gf_make_vandermonde(int rows, int cols)
    {
        int *vdm, i, j, k;
        void gf_modar_setup();

        if (rows >= 255 || cols >= 255)
        {
            printf("Error: gf_make_vandermonde: %d + %d >= %d\n");
        }

        vdm = (int *) malloc(sizeof(int) * rows * cols);
        if (vdm == NULL)
        {
            printf("Malloc: Vandermonde matrix");
        }
        for (i = 0; i < rows; i++)
        {
            k = 1;
            for (j = 0; j < cols; j++)
            {
                vdm[i*cols+j] = k;
                k = gf_single_multiply(k, i);
            }
        }
        return vdm;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0xff, -0xc(%rbp)
jge 0x3b4c
cmpl $0xff, -0x10(%rbp)
jl 0x3b5a
leaq 0x15d5(%rip), %rdi      # 0x5128
movb $0x0, %al
callq 0x2040
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
movslq -0x10(%rbp), %rax
imulq %rax, %rdi
callq 0x2190
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3b88
leaq 0x15d2(%rip), %rdi      # 0x5153
movb $0x0, %al
callq 0x2040
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3bee
movl $0x1, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x3be1
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %edx
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
imull -0x10(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x3c60
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3ba5
jmp 0x3be3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3b8f
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: syzcch[P]FEC_C_version/./fec_rs.h
// Function: rscode::find_swap_row(int*, int, int, int)
static int find_swap_row(int *matrix, int rows, int cols, int row_num)
    {
        int j;

        for (j = row_num; j < rows; j++)
        {
            if (matrix[j*cols+row_num] != 0) return j;
        }
        return -1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3c4b
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x18(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x3c3e
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3c52
jmp 0x3c40
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3c17
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: syzcch[P]FEC_C_version/./fec_rs.h
// Function: rscode::gf_single_multiply(int, int)
int gf_single_multiply(int xxx, int yyy)
    {
        unsigned int sum_j;
        unsigned char zzz;

        gf_modar_setup();
        if (xxx == 0 || yyy == 0)
        {
            zzz = 0;
        }
        else
        {
            sum_j = (int) (B_TO_J[xxx] + (int) B_TO_J[yyy]);
            zzz = J_TO_B[sum_j];
        }
        return zzz;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3cd0
cmpl $0x0, -0xc(%rbp)
je 0x3c87
cmpl $0x0, -0x10(%rbp)
jne 0x3c8d
movb $0x0, -0x15(%rbp)
jmp 0x3cbc
movq 0x349c(%rip), %rax      # 0x7130
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x348e(%rip), %rcx      # 0x7130
movslq -0x10(%rbp), %rdx
addl (%rcx,%rdx,4), %eax
movl %eax, -0x14(%rbp)
movq 0x3485(%rip), %rax      # 0x7138
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movb %al, -0x15(%rbp)
movzbl -0x15(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: syzcch[P]FEC_C_version/./fec_rs.h
// Function: rscode::gf_fast_add_parity(void*, void*, int)
void gf_fast_add_parity(void *to_add, void *to_modify, int size)
    {
        unsigned long *p, *t;
        int j;
        j = size/sizeof(unsigned long);
        t = (unsigned long *) to_add;
        p = (unsigned long *) to_modify;
        p += j;
        t += j;
        while(t != (unsigned long *) to_add)
        {
            p--;
            t--;
            *p = *p ^ *t;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
shrq $0x3, %rax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x3f31
movq -0x28(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x30(%rbp), %rax
xorq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3ef8
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)