LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: CMU-SAFARI[P]MQSim/src/utils/RandomGenerator.cpp
// Function: Utils::RandomGenerator::Poisson(double)
int64_t RandomGenerator::Poisson(double x)
	{
		double b = exp(-x);
		int64_t k = 0;
		double p = 1;
		while (p >= b) {
			++k;
			p *= FloatRandom();
		}

		return k - 1;
	}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd 0x28(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x87a0
movsd %xmm0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movsd 0x447e(%rip), %xmm0     # 0xabcc0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
ucomisd 0x20(%rsp), %xmm0
jb 0xa787c
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
callq 0xa6f20
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0xa7848
movq 0x18(%rsp), %rax
subq $0x1, %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/utils/RandomGenerator.cpp
// Function: Utils::RandomGenerator::Triangular(double, double, double)
double RandomGenerator::Triangular(double min, double middle, double max)
	{
		double y = FloatRandom();
		if (y <= (middle - min) / (max - min)) {
			return min + sqrt(y*max*middle - y*max*min - y*min*middle + y*min*min);
		} else {
			return max - sqrt(max*max + y*max*middle - y*max*max - y*min*middle + y*max*min - max*min - max*middle + min*middle);
		}
	}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
movsd %xmm2, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0xa6f20
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm1
movsd 0x28(%rsp), %xmm0
subsd 0x30(%rsp), %xmm0
movsd 0x20(%rsp), %xmm2
subsd 0x30(%rsp), %xmm2
divsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0xa7ade
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm2
movsd 0x18(%rsp), %xmm1
mulsd 0x20(%rsp), %xmm1
mulsd 0x30(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x18(%rsp), %xmm1
mulsd 0x30(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
mulsd 0x30(%rsp), %xmm0
movsd 0x30(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x8360
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0xa7c0e
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x20(%rsp), %xmm2
movsd 0x18(%rsp), %xmm1
mulsd 0x20(%rsp), %xmm1
mulsd 0x28(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x18(%rsp), %xmm1
mulsd 0x20(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
mulsd 0x30(%rsp), %xmm0
movsd 0x28(%rsp), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x18(%rsp), %xmm1
mulsd 0x20(%rsp), %xmm1
movsd 0x30(%rsp), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
movsd 0x30(%rsp), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x20(%rsp), %xmm1
movsd 0x28(%rsp), %xmm2
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x30(%rsp), %xmm0
movsd 0x28(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x8360
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
nopl (%rax)
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/utils/XMLWriter.cpp
// Function: Utils::XmlWriter::Open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool XmlWriter::Open(const std::string strFile) {

		outFile.open(strFile);
		if (outFile.is_open()) {
			outFile << "<?xml version=\"1.0\" encoding=\"us-ascii\"?>\n";
			indent = 0;
			openTags = 0;
			openElements = 0;

			return true;
		}

		return false;
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x10, %edx
callq 0x81f0
movq 0x8(%rsp), %rdi
callq 0x8340
testb $0x1, %al
jne 0xa7ce2
jmp 0xa7d1d
movq 0x8(%rsp), %rdi
leaq 0x6f2b(%rip), %rsi      # 0xaec19
callq 0x8440
movq 0x8(%rsp), %rax
movl $0x0, 0x200(%rax)
movl $0x0, 0x204(%rax)
movl $0x0, 0x208(%rax)
movb $0x1, 0x27(%rsp)
jmp 0xa7d22
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/utils/XMLWriter.cpp
// Function: Utils::XmlWriter::Write_open_tag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void XmlWriter::Write_open_tag(const std::string openTag) {
		if (outFile.is_open()) {
			for (int i = 0; i < indent; i++) {
				outFile << "\t";
			}
			tempOpenTag.resize(openTags + 1);
			outFile << "<" << openTag << ">\n";
			tempOpenTag[openTags] = openTag;
			indent += 1;
			openTags += 1;
		} else {
			PRINT_ERROR("The XML output file is closed. Unable to write to file");
		}
	}

// Assembly:
subq $0x28, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x8340
testb $0x1, %al
jne 0xa7d8a
jmp 0xa7e59
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x200(%rcx), %eax
jge 0xa7dc1
movq 0x8(%rsp), %rdi
leaq 0x3ccf(%rip), %rsi      # 0xaba7e
callq 0x8440
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xa7d92
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x210, %rdi            # imm = 0x210
movl 0x204(%rax), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0xa8730
movq 0x8(%rsp), %rdi
leaq 0x175d(%rip), %rsi      # 0xa954a
callq 0x8440
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x83e0
movq %rax, %rdi
leaq 0x6e77(%rip), %rsi      # 0xaec7f
callq 0x8440
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x210, %rdi            # imm = 0x210
movslq 0x204(%rax), %rsi
callq 0x3af10
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x8050
movq 0x8(%rsp), %rax
movl 0x200(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x200(%rax)
movl 0x204(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x204(%rax)
jmp 0xa7ea4
movq 0x32190(%rip), %rdi     # 0xd9ff0
leaq 0x2a81(%rip), %rsi      # 0xaa8e8
callq 0x8440
movq 0x3217d(%rip), %rdi     # 0xd9ff0
leaq 0x6dca(%rip), %rsi      # 0xaec44
callq 0x8440
movq %rax, %rdi
movq 0x320cf(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0x3213b(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
addq $0x28, %rsp
retq
nopl (%rax)
// File: CMU-SAFARI[P]MQSim/src/utils/XMLWriter.cpp
// Function: Utils::XmlWriter::Write_attribute_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void XmlWriter::Write_attribute_string(const std::string attribute_name, const std::string attribute_value)
	{
		if (outFile.is_open()) {
			for (int i = 0; i < indent + 1; i++) {
				outFile << "\t";
			}

			outFile << " <" << attribute_name + ">" + attribute_value + "</" << attribute_name + ">\n";
		} else {
			PRINT_ERROR("The XML output file is closed. Unable to write to file");
		}
	}

// Assembly:
subq $0xe8, %rsp
movq %rsi, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xe0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x8340
testb $0x1, %al
jne 0xa7ef4
jmp 0xa8087
movl $0x0, 0xcc(%rsp)
movq 0x30(%rsp), %rcx
movl 0xcc(%rsp), %eax
movl 0x200(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0xa7f3c
movq 0x30(%rsp), %rdi
leaq 0x3b5a(%rip), %rsi      # 0xaba7e
callq 0x8440
movl 0xcc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xcc(%rsp)
jmp 0xa7eff
movq 0x30(%rsp), %rdi
leaq 0x1601(%rip), %rsi      # 0xa9549
callq 0x8440
movq 0x20(%rsp), %rsi
movq %rax, 0x10(%rsp)
leaq 0x1624(%rip), %rdx      # 0xa9582
leaq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1fe40
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x88(%rsp), %rdi
callq 0x1ff40
jmp 0xa7f86
leaq 0x6cee(%rip), %rdx      # 0xaec7b
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xd060
jmp 0xa7fa4
movq 0x10(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x83e0
movq %rax, 0x8(%rsp)
jmp 0xa7fbd
movq 0x20(%rsp), %rsi
leaq 0x6cb6(%rip), %rdx      # 0xaec7f
leaq 0x38(%rsp), %rdi
callq 0x1fe40
jmp 0xa7fd5
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x83e0
jmp 0xa7fe6
leaq 0x38(%rsp), %rdi
callq 0x8848
leaq 0xa8(%rsp), %rdi
callq 0x8848
leaq 0x88(%rsp), %rdi
callq 0x8848
leaq 0x68(%rsp), %rdi
callq 0x8848
jmp 0xa80d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xa807b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xa806e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xa8061
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x8848
leaq 0xa8(%rsp), %rdi
callq 0x8848
leaq 0x88(%rsp), %rdi
callq 0x8848
leaq 0x68(%rsp), %rdi
callq 0x8848
jmp 0xa80da
movq 0x31f62(%rip), %rdi     # 0xd9ff0
leaq 0x2853(%rip), %rsi      # 0xaa8e8
callq 0x8440
movq 0x31f4f(%rip), %rdi     # 0xd9ff0
leaq 0x6b9c(%rip), %rsi      # 0xaec44
callq 0x8440
movq %rax, %rdi
movq 0x31ea1(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0x31f0d(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
addq $0xe8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x8770
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/utils/XMLWriter.cpp
// Function: Utils::XmlWriter::Write_close_tag()
void XmlWriter::Write_close_tag() {
		if (outFile.is_open()) {
			indent -= 1;
			for (int i = 0; i < indent; i++) {
				outFile << "\t";
			}
			outFile << "</" << tempOpenTag[openTags - 1] << ">\n";
			tempOpenTag.resize(openTags - 1);
			openTags -= 1;
		} else {
			PRINT_ERROR("The XML output file is closed. Unable to write to file");
		}
	}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x8340
testb $0x1, %al
jne 0xa8111
jmp 0xa81e7
movq 0x10(%rsp), %rax
movl 0x200(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x200(%rax)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x200(%rcx), %eax
jge 0xa815c
movq 0x10(%rsp), %rdi
leaq 0x3934(%rip), %rsi      # 0xaba7e
callq 0x8440
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xa812d
movq 0x10(%rsp), %rdi
leaq 0x6b13(%rip), %rsi      # 0xaec7b
callq 0x8440
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq %rax, %rdi
addq $0x210, %rdi            # imm = 0x210
movl 0x204(%rax), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x3af10
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x83e0
movq %rax, %rdi
leaq 0x6ad3(%rip), %rsi      # 0xaec7f
callq 0x8440
movq 0x10(%rsp), %rax
movq %rax, %rdi
addq $0x210, %rdi            # imm = 0x210
movl 0x204(%rax), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0xa8730
movq 0x10(%rsp), %rax
movl 0x204(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x204(%rax)
jmp 0xa8232
movq 0x31e02(%rip), %rdi     # 0xd9ff0
leaq 0x26f3(%rip), %rsi      # 0xaa8e8
callq 0x8440
movq 0x31def(%rip), %rdi     # 0xd9ff0
leaq 0x6a3c(%rip), %rsi      # 0xaec44
callq 0x8440
movq %rax, %rdi
movq 0x31d41(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0x31dad(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/utils/XMLWriter.cpp
// Function: Utils::XmlWriter::Write_start_element_tag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void XmlWriter::Write_start_element_tag(const std::string elementTag) {
		if (outFile.is_open()) {
			for (int i = 0; i < indent; i++) {
				outFile << "\t";
			}
			tempElementTag.resize(openElements + 1);
			tempElementTag[openElements] = elementTag;
			openElements += 1;
			outFile << "<" << elementTag;
		} else {
			PRINT_ERROR("The XML output file is closed. Unable to write to file");
		}
	}

// Assembly:
subq $0x28, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x8340
testb $0x1, %al
jne 0xa826a
jmp 0xa8316
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x200(%rcx), %eax
jge 0xa82a1
movq 0x8(%rsp), %rdi
leaq 0x37ef(%rip), %rsi      # 0xaba7e
callq 0x8440
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xa8272
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x228, %rdi            # imm = 0x228
movl 0x208(%rax), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0xa8730
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x228, %rdi            # imm = 0x228
movslq 0x208(%rax), %rsi
callq 0x3af10
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x8050
movq 0x8(%rsp), %rdi
movl 0x208(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x208(%rdi)
leaq 0x1247(%rip), %rsi      # 0xa954a
callq 0x8440
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x83e0
jmp 0xa8361
movq 0x31cd3(%rip), %rdi     # 0xd9ff0
leaq 0x25c4(%rip), %rsi      # 0xaa8e8
callq 0x8440
movq 0x31cc0(%rip), %rdi     # 0xd9ff0
leaq 0x690d(%rip), %rsi      # 0xaec44
callq 0x8440
movq %rax, %rdi
movq 0x31c12(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0x31c7e(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/utils/XMLWriter.cpp
// Function: Utils::XmlWriter::Write_end_element_tag()
void XmlWriter::Write_end_element_tag()
	{
		if (outFile.is_open()) {
			outFile << "/>\n";
			tempElementTag.resize(openElements - 1);
			openElements -= 1;
		} else {
			PRINT_ERROR("The XML output file is closed. Unable to write to file");
		}
	}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x8340
testb $0x1, %al
jne 0xa838e
jmp 0xa83d5
movq 0x8(%rsp), %rdi
leaq 0x68e4(%rip), %rsi      # 0xaec7e
callq 0x8440
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x228, %rdi            # imm = 0x228
movl 0x208(%rax), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0xa8730
movq 0x8(%rsp), %rax
movl 0x208(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x208(%rax)
jmp 0xa8420
movq 0x31c14(%rip), %rdi     # 0xd9ff0
leaq 0x2505(%rip), %rsi      # 0xaa8e8
callq 0x8440
movq 0x31c01(%rip), %rdi     # 0xd9ff0
leaq 0x684e(%rip), %rsi      # 0xaec44
callq 0x8440
movq %rax, %rdi
movq 0x31b53(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0x31bbf(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/utils/XMLWriter.cpp
// Function: Utils::XmlWriter::Write_attribute(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void XmlWriter::Write_attribute(const std::string outAttribute)
	{
		if (outFile.is_open()) {
			outFile << " " << outAttribute;
		} else {
			PRINT_ERROR("The XML output file is closed. Unable to write to file");
		}
	}

// Assembly:
subq $0x28, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x8340
testb $0x1, %al
jne 0xa8458
jmp 0xa8478
movq 0x10(%rsp), %rdi
leaq 0x3a3a(%rip), %rsi      # 0xabe9e
callq 0x8440
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x83e0
jmp 0xa84c3
movq 0x31b71(%rip), %rdi     # 0xd9ff0
leaq 0x2462(%rip), %rsi      # 0xaa8e8
callq 0x8440
movq 0x31b5e(%rip), %rdi     # 0xd9ff0
leaq 0x67ab(%rip), %rsi      # 0xaec44
callq 0x8440
movq %rax, %rdi
movq 0x31ab0(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0x31b1c(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/utils/XMLWriter.cpp
// Function: Utils::XmlWriter::Write_attribute_string_inline(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void XmlWriter::Write_attribute_string_inline(const std::string attribute_name, const std::string attribute_value)
	{
		if (outFile.is_open()) {
			outFile << " ";
			outFile << attribute_name + "=\"" + attribute_value + "\"";
		} else {
			PRINT_ERROR("The XML output file is closed. Unable to write to file");
		}
	}

// Assembly:
subq $0xb8, %rsp
movq %rsi, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x8340
testb $0x1, %al
jne 0xa8514
jmp 0xa8606
movq 0x28(%rsp), %rdi
leaq 0x397e(%rip), %rsi      # 0xabe9e
callq 0x8440
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x6747(%rip), %rdx      # 0xaec82
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1fe40
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x1ff40
jmp 0xa8560
leaq 0x109a(%rip), %rdx      # 0xa9601
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xd060
jmp 0xa857b
movq 0x8(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x83e0
jmp 0xa858f
leaq 0x80(%rsp), %rdi
callq 0x8848
leaq 0x60(%rsp), %rdi
callq 0x8848
leaq 0x40(%rsp), %rdi
callq 0x8848
jmp 0xa8651
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0xa85fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0xa85f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x8848
leaq 0x60(%rsp), %rdi
callq 0x8848
leaq 0x40(%rsp), %rdi
callq 0x8848
jmp 0xa8659
movq 0x319e3(%rip), %rdi     # 0xd9ff0
leaq 0x22d4(%rip), %rsi      # 0xaa8e8
callq 0x8440
movq 0x319d0(%rip), %rdi     # 0xd9ff0
leaq 0x661d(%rip), %rsi      # 0xaec44
callq 0x8440
movq %rax, %rdi
movq 0x31922(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0x3198e(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
addq $0xb8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x8770
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]MQSim/src/utils/XMLWriter.cpp
// Function: Utils::XmlWriter::Write_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void XmlWriter::Write_string(const std::string outString)
	{
		if (outFile.is_open()) {
			outFile << ">" << outString;
		} else {
			PRINT_ERROR("The XML output file is closed. Unable to write to file");
		}
	}

// Assembly:
subq $0x28, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x8340
testb $0x1, %al
jne 0xa8698
jmp 0xa86b8
movq 0x10(%rsp), %rdi
leaq 0xede(%rip), %rsi       # 0xa9582
callq 0x8440
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x83e0
jmp 0xa8703
movq 0x31931(%rip), %rdi     # 0xd9ff0
leaq 0x2222(%rip), %rsi      # 0xaa8e8
callq 0x8440
movq 0x3191e(%rip), %rdi     # 0xd9ff0
leaq 0x656b(%rip), %rsi      # 0xaec44
callq 0x8440
movq %rax, %rdi
movq 0x31870(%rip), %rsi     # 0xd9f58
callq 0x8480
movq 0x318dc(%rip), %rdi     # 0xd9fd0
callq 0x84f0
movl $0x1, %edi
callq 0x8500
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: vssense[P]Compiler/src/middle-end/middle-end_main.cpp
// Function: main
int main()
{
    Tree* tree = GetTreeFromFile(tree_tmp_file);
    Optimize(tree);
    WriteToFile(tree, tree_tmp_file);

    DestructTree(tree);
    DeleteTree(tree);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq 0x8e3a(%rip), %rdi      # 0xb0d0
callq 0x24d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x28b0
movq -0x10(%rbp), %rdi
movq 0x8e1d(%rip), %rsi      # 0xb0d0
callq 0x22e0
movq -0x10(%rbp), %rdi
callq 0x4660
movq -0x10(%rbp), %rdi
callq 0x46f0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: vssense[P]Compiler/src/middle-end/tree_optimize.cpp
// Function: CalculateConsts(Tree*, Node*)
void CalculateConsts(Tree* tree, Node* node)
{
    assert(tree);

    if (node == nullptr)
    {
    	return;
    }

    CalculateConsts(tree, node->right);
    CalculateConsts(tree, node->left);

    if (node->type == MATH_TYPE)
    {
        if (node->right->type == NUMB_TYPE && 
        	node->left ->type == NUMB_TYPE)
        {
            CalculateOP(node);
            node->type = NUMB_TYPE;

            free(node->right);
            node->right = nullptr;
            free(node->left);
            node->left = nullptr;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2919
jmp 0x2938
leaq 0x46f7(%rip), %rdi      # 0x7017
leaq 0x4841(%rip), %rsi      # 0x7168
movl $0xf, %edx
leaq 0x486c(%rip), %rcx      # 0x719f
callq 0x2090
cmpq $0x0, -0x10(%rbp)
jne 0x2944
jmp 0x29d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x2900
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x2900
movq -0x10(%rbp), %rax
cmpl $0xe, (%rax)
jne 0x29d0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0xf, (%rax)
jne 0x29ce
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0xf, (%rax)
jne 0x29ce
movq -0x10(%rbp), %rdi
callq 0x29e0
movq -0x10(%rbp), %rax
movl $0xf, (%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2110
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2110
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
jmp 0x29d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: maclellant[P]ReliableGoBackN/client.cpp
// Function: request_func(int, char*, unsigned long, sockaddr_in)
void request_func(int sockfd, char* filename, size_t length, sockaddr_in server)
{
    socklen_t slen = sizeof(server);
    Packet packet = Packet(filename, length, 0, GET);

    if (sendto(sockfd, packet.buffer, PACKET_SIZE, 0, (struct sockaddr*) &server, slen) == -1)
    {
        perror("Error: could not send acknowledge to client\n");
        close(sockfd);
        exit(EXIT_FAILURE);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rcx, -0x10(%rbp)
movq %r8, -0x8(%rbp)
movl %edi, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movl $0x10, -0x2c(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rax
leaq -0x22c(%rbp), %rdi
xorl %ecx, %ecx
movl $0x2, %r8d
movzwl %ax, %edx
callq 0x38e0
movl -0x14(%rbp), %edi
leaq -0x22c(%rbp), %rsi
movl -0x2c(%rbp), %r9d
movl $0x200, %edx            # imm = 0x200
xorl %ecx, %ecx
leaq -0x10(%rbp), %r8
callq 0x2060
cmpq $-0x1, %rax
jne 0x2be6
leaq 0x1562(%rip), %rdi      # 0x4131
callq 0x2180
movl -0x14(%rbp), %edi
callq 0x2320
movl $0x1, %edi
callq 0x2240
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
nop
// File: iZhangHui[P]CppPrimer/CH04_Expressions/examples/cond.cc
// Function: main
int main()
{
	unsigned i;
	while (cin >> i)
		grades.push_back(i);

	for (auto grade : grades) {  // for each grade in grades
		// set the initial grade as pass or fail
		string finalgrade = (grade < 60) ?  "fail" : "pass";

		finalgrade = (grade > 90) ? "high pass"
				                  : (grade < 60) ? "fail" : "pass";

		cout << grade << " " + finalgrade << endl;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x0, -0x4(%rbp)
movq 0x3c57(%rip), %rdi      # 0x5fe0
leaq -0x8(%rbp), %rsi
callq 0x2030
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x2150
testb $0x1, %al
jne 0x23a7
jmp 0x23b9
leaq 0x3d7a(%rip), %rdi      # 0x6128
leaq -0x8(%rbp), %rsi
callq 0x2620
jmp 0x2382
leaq 0x3d68(%rip), %rax      # 0x6128
movq %rax, -0x10(%rbp)
leaq 0x3d5d(%rip), %rdi      # 0x6128
callq 0x2690
movq %rax, -0x18(%rbp)
leaq 0x3d4d(%rip), %rdi      # 0x6128
callq 0x26c0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x26f0
testb $0x1, %al
jne 0x23fa
jmp 0x258b
leaq -0x18(%rbp), %rdi
callq 0x2730
movl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x3c, -0x24(%rbp)
jae 0x241e
leaq 0x1bef(%rip), %rax      # 0x4004
movq %rax, -0x88(%rbp)
jmp 0x242e
leaq 0x1be9(%rip), %rax      # 0x400e
movq %rax, -0x88(%rbp)
jmp 0x242e
movq -0x88(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x21e0
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x2180
jmp 0x2465
leaq -0x49(%rbp), %rdi
callq 0x2140
cmpl $0x5a, -0x24(%rbp)
jbe 0x2484
leaq 0x1b8e(%rip), %rax      # 0x4009
movq %rax, -0xa0(%rbp)
jmp 0x24b8
cmpl $0x3c, -0x24(%rbp)
jae 0x249a
leaq 0x1b73(%rip), %rax      # 0x4004
movq %rax, -0xa8(%rbp)
jmp 0x24aa
leaq 0x1b6d(%rip), %rax      # 0x400e
movq %rax, -0xa8(%rbp)
jmp 0x24aa
movq -0xa8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x2170
jmp 0x24ca
movl -0x24(%rbp), %esi
movq 0x3afc(%rip), %rdi      # 0x5fd0
callq 0x2160
movq %rax, -0xb0(%rbp)
jmp 0x24e2
leaq 0x1b2a(%rip), %rsi      # 0x4013
leaq -0x80(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x2750
jmp 0x24f8
movq -0xb0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2100
movq %rax, -0xb8(%rbp)
jmp 0x2511
movq -0xb8(%rbp), %rdi
movq 0x3aa1(%rip), %rsi      # 0x5fc0
callq 0x2130
jmp 0x2526
leaq -0x80(%rbp), %rdi
callq 0x20c0
leaq -0x48(%rbp), %rdi
callq 0x20c0
leaq -0x18(%rbp), %rdi
callq 0x2860
jmp 0x23e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x2140
jmp 0x2596
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2580
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x20c0
leaq -0x48(%rbp), %rdi
callq 0x20c0
jmp 0x2596
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x21d0
nop
// File: ksraj123[P]RAW12-to-bitmap-AVI/src/ImageLoader.cpp
// Function: ImageLoader::LoadImage()
void ImageLoader::LoadImage()
{
    _intputFile.open(_filePath, std::ios::binary);
    if(!_intputFile)
    {
        std::cerr << "Error: File cannot be opened\b\tExiting" << std::endl;
        exit(1);
    }
        _intputFile.read(fileData, INPUT_SIZE);
    for (int itrFileData = 0, itrCfa = 0; itrFileData < INPUT_SIZE, itrCfa < TOTAL_PIX; itrFileData += 3, itrCfa+=2)
    {
        cfa[itrCfa] = fileData[itrFileData];
        cfa[itrCfa + 1] = Sensel(fileData[itrFileData + 1], fileData[itrFileData + 2]);
    }
    _intputFile.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq %rsi, %rdi
addq $0x28, %rdi
addq $0x8, %rsi
movl $0x4, %edx
callq 0x21b0
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x28, %rdi
movq 0x28(%rax), %rax
addq -0x18(%rax), %rdi
callq 0x20f0
testb $0x1, %al
jne 0x3227
jmp 0x3253
movq 0x5dc2(%rip), %rdi      # 0x8ff0
leaq 0x3045(%rip), %rsi      # 0x627a
callq 0x21e0
movq %rax, %rdi
movq 0x5d7c(%rip), %rsi      # 0x8fc0
callq 0x2200
movl $0x1, %edi
callq 0x2260
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x28, %rdi
movq (%rax), %rsi
movl $0x1200000, %edx        # imm = 0x1200000
callq 0x2280
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0xc00000, -0x10(%rbp)  # imm = 0xC00000
jge 0x32fd
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movslq -0xc(%rbp), %rdx
movb (%rcx,%rdx), %sil
movq 0x230(%rax), %rcx
movslq -0x10(%rbp), %rdx
movb %sil, (%rcx,%rdx)
movq (%rax), %rcx
movl -0xc(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
andl $0xf, %ecx
shll $0x4, %ecx
movq (%rax), %rdx
movl -0xc(%rbp), %esi
addl $0x2, %esi
movslq %esi, %rsi
movsbl (%rdx,%rsi), %edx
andl $0xf0, %edx
sarl $0x4, %edx
orl %edx, %ecx
movb %cl, %dl
movq 0x230(%rax), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x3, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x10(%rbp)
jmp 0x3279
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x2070
addq $0x20, %rsp
popq %rbp
retq
// File: ksraj123[P]RAW12-to-bitmap-AVI/src/OutputWriter.cpp
// Function: OutputWriter::Print5by5tile(unsigned char*)
void OutputWriter::Print5by5tile(uint8_t* array)
{
    for (int row = 0; row < 5; ++row)
    {
        for (int index = 0; index < 5; ++index)
        {
            std::cout << (int)array[row * IMAGE_WIDTH + index] << " ";
        }
        std::cout << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x5, -0xc(%rbp)
jge 0x338e
movl $0x0, -0x10(%rbp)
cmpl $0x5, -0x10(%rbp)
jge 0x3370
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
shll $0xc, %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %esi
movq 0x5c7f(%rip), %rdi      # 0x8fd0
callq 0x2320
movq %rax, %rdi
leaq 0x2f78(%rip), %rsi      # 0x62d8
callq 0x21e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3330
movq 0x5c59(%rip), %rdi      # 0x8fd0
movq 0x5c42(%rip), %rsi      # 0x8fc0
callq 0x2200
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3323
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ksraj123[P]RAW12-to-bitmap-AVI/src/OutputWriter.cpp
// Function: OutputWriter::ConvertToPPM(unsigned char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
uint8_t* OutputWriter::ConvertToPPM(uint8_t* channel, std::string chanelName)
{
    uint8_t* ppmBin = new uint8_t[3 * TOTAL_PIX]{0};
    for (int itrPpmBin = 0, itrChnl = 0; itrPpmBin < 3 * TOTAL_PIX, 
                            itrChnl < TOTAL_PIX; itrPpmBin += 3, ++itrChnl)
    {
        switch (chanelName[0])
        {
            case 'r':
                ppmBin[itrPpmBin] = channel[itrChnl];
                break;
            case 'g':
                ppmBin[itrPpmBin + 1] = channel[itrChnl];
                break;
            case 'b':
                ppmBin[itrPpmBin + 2] = channel[itrChnl];
                break;
        }      
    }
    return ppmBin;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x2400000, %edi        # imm = 0x2400000
callq 0x2030
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
movb $0x0, (%rdi)
addq $0x1, %rdi
xorl %esi, %esi
movl $0x23fffff, %edx        # imm = 0x23FFFFF
callq 0x2120
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0xc00000, -0x28(%rbp)  # imm = 0xC00000
jge 0x3a66
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2390
movsbl (%rax), %eax
movl %eax, -0x3c(%rbp)
subl $0x62, %eax
je 0x3a32
jmp 0x39e9
movl -0x3c(%rbp), %eax
subl $0x67, %eax
je 0x3a15
jmp 0x39f3
movl -0x3c(%rbp), %eax
subl $0x72, %eax
jne 0x3a4d
jmp 0x39fd
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x3a4d
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x3a4d
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x3a4f
movl -0x24(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x39c2
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: ksraj123[P]RAW12-to-bitmap-AVI/src/OutputWriter.cpp
// Function: OutputWriter::ConvertToBMP(unsigned char*, unsigned char*, unsigned char*)
uint8_t* OutputWriter::ConvertToBMP(uint8_t* channelRed, uint8_t* channelBlue, 
                                  uint8_t* channelGreen)
{
    uint8_t* bmpBin = new uint8_t [TOTAL_PIX * 3];
    for (int row = IMAGE_HEIGHT - 1, itr = 0; row >= 0; --row)
    {
        for (int col = row * IMAGE_WIDTH; col < (row + 1) * IMAGE_WIDTH; ++col)
        {
            bmpBin[itr]     = channelBlue[col];
            bmpBin[itr + 1] = channelGreen[col];
            bmpBin[itr + 2] = channelRed[col];
            itr += 3;
        }
    }
    return bmpBin;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x2400000, %edi        # imm = 0x2400000
callq 0x2030
movq %rax, -0x28(%rbp)
movl $0xbff, -0x2c(%rbp)     # imm = 0xBFF
movl $0x0, -0x30(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x3d47
movl -0x2c(%rbp), %eax
shll $0xc, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl -0x2c(%rbp), %ecx
addl $0x1, %ecx
shll $0xc, %ecx
cmpl %ecx, %eax
jge 0x3d37
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movl -0x30(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movl -0x30(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x30(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3cc7
jmp 0x3d39
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3cb4
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ksraj123[P]RAW12-to-bitmap-AVI/src/OutputWriter.cpp
// Function: Chunk::WriteToFile(std::basic_ofstream<char, std::char_traits<char>>*)
void Chunk::WriteToFile(std::ofstream* outputAVI)
{
    outputAVI->write(reinterpret_cast<const char*>(_fourCC), 4);
    outputAVI->write(reinterpret_cast<const char*>(&_size), 4);
    if (_avi == nullptr)
    {
        _size = 0;
    }
    outputAVI->write(reinterpret_cast<const char*>(_avi), _size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %edx
callq 0x2290
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x4, %rsi
movl $0x4, %edx
callq 0x2290
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3e12
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x8(%rax), %rsi
movl 0x4(%rax), %eax
movl %eax, %edx
callq 0x2290
addq $0x20, %rsp
popq %rbp
retq
nop
// File: ksraj123[P]RAW12-to-bitmap-AVI/src/ImageProcessor.cpp
// Function: ImageProcessor::InitializeRedChannel(unsigned char*)
void ImageProcessor::InitializeRedChannel(uint8_t* cfa)
{
    for (int itrRed = 0; itrRed < TOTAL_PIX;)
    {
        int row = itrRed / IMAGE_WIDTH;
        if (row % 2 == 0)
        {
            redChannel[itrRed] = cfa[itrRed];
            itrRed += 2;
        }
        else
        {
            itrRed += IMAGE_WIDTH;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xc00000, -0x14(%rbp)  # imm = 0xC00000
jge 0x4d83
movl -0x14(%rbp), %eax
movl $0x1000, %ecx           # imm = 0x1000
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x4d76
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movb (%rcx,%rdx), %dl
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
jmp 0x4d81
movl -0x14(%rbp), %eax
addl $0x1000, %eax           # imm = 0x1000
movl %eax, -0x14(%rbp)
jmp 0x4d2b
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ksraj123[P]RAW12-to-bitmap-AVI/src/ImageProcessor.cpp
// Function: ImageProcessor::InitializeGreenChannel(unsigned char*)
void ImageProcessor::InitializeGreenChannel(uint8_t* cfa)
{
    for (int itrGreen = 1; itrGreen < TOTAL_PIX; itrGreen += 2)
    {
        int row = itrGreen / IMAGE_WIDTH;
        if (row % 2 == 0)
        {
            greenChannel[itrGreen] = cfa[itrGreen];
        }
        else
        {
            greenChannel[itrGreen - 1] = cfa[itrGreen - 1];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x14(%rbp)
cmpl $0xc00000, -0x14(%rbp)  # imm = 0xC00000
jge 0x4e1f
movl -0x14(%rbp), %eax
movl $0x1000, %ecx           # imm = 0x1000
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x4dee
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movb (%rcx,%rdx), %dl
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x4e12
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movb (%rcx,%rdx), %dl
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x4e14
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
jmp 0x4dab
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ksraj123[P]RAW12-to-bitmap-AVI/src/ImageProcessor.cpp
// Function: ImageProcessor::InitializeBlueChannel(unsigned char*)
void ImageProcessor::InitializeBlueChannel(uint8_t* cfa)
{
    for (int itrBlue = IMAGE_WIDTH + 1; itrBlue < TOTAL_PIX;)
    {
        int row = itrBlue / IMAGE_WIDTH;
        if (row % 2 != 0)
        {
            blueChannel[itrBlue] = cfa[itrBlue];
            itrBlue += 2;
        }
        else
        {
            itrBlue += IMAGE_WIDTH;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1001, -0x14(%rbp)    # imm = 0x1001
cmpl $0xc00000, -0x14(%rbp)  # imm = 0xC00000
jge 0x4ea4
movl -0x14(%rbp), %eax
movl $0x1000, %ecx           # imm = 0x1000
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x4e97
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movb (%rcx,%rdx), %dl
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
jmp 0x4ea2
movl -0x14(%rbp), %eax
addl $0x1000, %eax           # imm = 0x1000
movl %eax, -0x14(%rbp)
jmp 0x4e4b
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ksraj123[P]RAW12-to-bitmap-AVI/src/ImageProcessor.cpp
// Function: ImageProcessor::Red()
void ImageProcessor::Red()
{
    int row;
    for (int itrChnl = 1; itrChnl < TOTAL_PIX; itrChnl += 2)
    {
        row = itrChnl / IMAGE_WIDTH;
        if (row % 2 == 1)
        {
            redChannel[itrChnl - 1] = (redChannel[itrChnl - 1 - IMAGE_WIDTH] 
                                 +  redChannel[itrChnl - 1 + IMAGE_WIDTH]) / 2;
            redChannel[itrChnl + 1] = (redChannel[itrChnl+1-IMAGE_WIDTH] 
                                 +  redChannel[itrChnl+1+IMAGE_WIDTH]) / 2;
        }
        redChannel[itrChnl] = (redChannel[itrChnl - 1] + redChannel[itrChnl + 1]) / 2;
    }
    std::fill(redChannel, redChannel+IMAGE_WIDTH, 0); // first row
    std::fill(redChannel + TOTAL_PIX - IMAGE_WIDTH, redChannel + TOTAL_PIX, 0); //last row
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, -0x10(%rbp)
cmpl $0xc00000, -0x10(%rbp)  # imm = 0xC00000
jge 0x4fe2
movl -0x10(%rbp), %eax
movl $0x1000, %ecx           # imm = 0x1000
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x1, %edx
jne 0x4f94
movq -0x20(%rbp), %rcx
movq (%rcx), %rax
movl -0x10(%rbp), %edx
subl $0x1, %edx
subl $0x1000, %edx           # imm = 0x1000
movslq %edx, %rdx
movzbl (%rax,%rdx), %eax
movq (%rcx), %rdx
movl -0x10(%rbp), %esi
subl $0x1, %esi
addl $0x1000, %esi           # imm = 0x1000
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
addl %edx, %eax
movl $0x2, %esi
cltd
idivl %esi
movb %al, %sil
movq (%rcx), %rax
movl -0x10(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movb %sil, (%rax,%rdx)
movq (%rcx), %rax
movl -0x10(%rbp), %edx
addl $0x1, %edx
subl $0x1000, %edx           # imm = 0x1000
movslq %edx, %rdx
movzbl (%rax,%rdx), %eax
movq (%rcx), %rcx
movl -0x10(%rbp), %edx
addl $0x1, %edx
addl $0x1000, %edx           # imm = 0x1000
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movb %cl, %dl
movq (%rax), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rcx
movq (%rcx), %rax
movl -0x10(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movzbl (%rax,%rdx), %eax
movq (%rcx), %rcx
movl -0x10(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movb %cl, %dl
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x10(%rbp)
jmp 0x4ecb
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq (%rax), %rsi
addq $0x1000, %rsi           # imm = 0x1000
movl $0x0, -0x14(%rbp)
leaq -0x14(%rbp), %rdx
callq 0x5320
movq -0x20(%rbp), %rax
movq (%rax), %rdi
addq $0xc00000, %rdi         # imm = 0xC00000
addq $-0x1000, %rdi          # imm = 0xF000
movq (%rax), %rsi
addq $0xc00000, %rsi         # imm = 0xC00000
movl $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rdx
callq 0x5320
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ksraj123[P]RAW12-to-bitmap-AVI/src/ImageProcessor.cpp
// Function: ImageProcessor::Blue()
void ImageProcessor::Blue()
{
    int row;
    for (int itrChnl = 0; itrChnl < TOTAL_PIX; itrChnl += 2)
    {
        row = itrChnl / IMAGE_WIDTH;
        if (row % 2 == 0)
        {
            blueChannel[itrChnl - 1] = (blueChannel[itrChnl - 1 - IMAGE_WIDTH] 
                                 +  blueChannel[itrChnl - 1 + IMAGE_WIDTH]) / 2;
            blueChannel[itrChnl + 1] = (blueChannel[itrChnl+1-IMAGE_WIDTH] 
                                 +  blueChannel[itrChnl+1+IMAGE_WIDTH]) / 2;
        }
        blueChannel[itrChnl] = (blueChannel[itrChnl - 1] + blueChannel[itrChnl + 1]) / 2;
    }
    std::fill(blueChannel, blueChannel+IMAGE_WIDTH, 0); // first row
    std::fill(blueChannel + TOTAL_PIX - IMAGE_WIDTH, blueChannel + TOTAL_PIX, 0); //last row
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0xc00000, -0x10(%rbp)  # imm = 0xC00000
jge 0x517b
movl -0x10(%rbp), %eax
movl $0x1000, %ecx           # imm = 0x1000
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x512a
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
movl -0x10(%rbp), %edx
subl $0x1, %edx
subl $0x1000, %edx           # imm = 0x1000
movslq %edx, %rdx
movzbl (%rax,%rdx), %eax
movq 0x8(%rcx), %rdx
movl -0x10(%rbp), %esi
subl $0x1, %esi
addl $0x1000, %esi           # imm = 0x1000
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
addl %edx, %eax
movl $0x2, %esi
cltd
idivl %esi
movb %al, %sil
movq 0x8(%rcx), %rax
movl -0x10(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movb %sil, (%rax,%rdx)
movq 0x8(%rcx), %rax
movl -0x10(%rbp), %edx
addl $0x1, %edx
subl $0x1000, %edx           # imm = 0x1000
movslq %edx, %rdx
movzbl (%rax,%rdx), %eax
movq 0x8(%rcx), %rcx
movl -0x10(%rbp), %edx
addl $0x1, %edx
addl $0x1000, %edx           # imm = 0x1000
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movb %cl, %dl
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
movl -0x10(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movzbl (%rax,%rdx), %eax
movq 0x8(%rcx), %rcx
movl -0x10(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movb %cl, %dl
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x10(%rbp)
jmp 0x505b
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rax), %rsi
addq $0x1000, %rsi           # imm = 0x1000
movl $0x0, -0x14(%rbp)
leaq -0x14(%rbp), %rdx
callq 0x5320
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0xc00000, %rdi         # imm = 0xC00000
addq $-0x1000, %rdi          # imm = 0xF000
movq 0x8(%rax), %rsi
addq $0xc00000, %rsi         # imm = 0xC00000
movl $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rdx
callq 0x5320
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ksraj123[P]RAW12-to-bitmap-AVI/src/ImageProcessor.cpp
// Function: ImageProcessor::Green()
void ImageProcessor::Green()
{
    for (int itrChnl = IMAGE_WIDTH+1; itrChnl < TOTAL_PIX;)
    {
        greenChannel[itrChnl] = (greenChannel[itrChnl - 1] + greenChannel[itrChnl + 1] 
                         +  greenChannel[itrChnl - IMAGE_WIDTH]
                         +  greenChannel[itrChnl + IMAGE_WIDTH])/4;
        if (itrChnl / IMAGE_WIDTH != (itrChnl + 2) / IMAGE_WIDTH)
        {
            itrChnl += 3;
            continue;
        }
        itrChnl += 2;
    }
    std::fill(greenChannel, greenChannel+IMAGE_WIDTH, 0); //first row
    std::fill(greenChannel + TOTAL_PIX - IMAGE_WIDTH, greenChannel + TOTAL_PIX, 0); //last row
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1001, -0xc(%rbp)     # imm = 0x1001
cmpl $0xc00000, -0xc(%rbp)   # imm = 0xC00000
jge 0x52b8
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rax
movl -0xc(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movzbl (%rax,%rdx), %eax
movq 0x10(%rcx), %rdx
movl -0xc(%rbp), %esi
addl $0x1, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
addl %edx, %eax
movq 0x10(%rcx), %rdx
movl -0xc(%rbp), %esi
subl $0x1000, %esi           # imm = 0x1000
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
addl %edx, %eax
movq 0x10(%rcx), %rcx
movl -0xc(%rbp), %edx
addl $0x1000, %edx           # imm = 0x1000
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movb %cl, %dl
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
movl $0x1000, %ecx           # imm = 0x1000
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl $0x1000, %ecx           # imm = 0x1000
cltd
idivl %ecx
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
je 0x52aa
movl -0xc(%rbp), %eax
addl $0x3, %eax
movl %eax, -0xc(%rbp)
jmp 0x51fb
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rbp)
jmp 0x51fb
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rax), %rsi
addq $0x1000, %rsi           # imm = 0x1000
movl $0x0, -0x10(%rbp)
leaq -0x10(%rbp), %rdx
callq 0x5320
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0xc00000, %rdi         # imm = 0xC00000
addq $-0x1000, %rdi          # imm = 0xF000
movq 0x10(%rax), %rsi
addq $0xc00000, %rsi         # imm = 0xC00000
movl $0x0, -0x14(%rbp)
leaq -0x14(%rbp), %rdx
callq 0x5320
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: razimantv[P]DancingLinks/spangram/spangram.cpp
// Function: contains_pair(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>> const&, std::pair<int, int> const&, std::pair<int, int> const&)
bool contains_pair(const Path& path, const Cell& c1, const Cell& c2) {
  for (int i = 1, l = path.size(); i < l; ++i)
    if ((path[i] == c1 && path[i - 1] == c2) ||
        (path[i] == c2 && path[i - 1] == c1))
      return true;
  return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl $0x1, 0x4(%rsp)
movq 0x18(%rsp), %rdi
callq 0x5690
movl %eax, (%rsp)
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
jge 0x386e
movq 0x18(%rsp), %rdi
movslq 0x4(%rsp), %rsi
callq 0x56f0
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x56b0
testb $0x1, %al
jne 0x37e7
jmp 0x380c
movq 0x18(%rsp), %rdi
movl 0x4(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x56f0
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x56b0
testb $0x1, %al
jne 0x3855
movq 0x18(%rsp), %rdi
movslq 0x4(%rsp), %rsi
callq 0x56f0
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x56b0
testb $0x1, %al
jne 0x382e
jmp 0x385c
movq 0x18(%rsp), %rdi
movl 0x4(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x56f0
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x56b0
testb $0x1, %al
jne 0x3855
jmp 0x385c
movb $0x1, 0x27(%rsp)
jmp 0x3873
jmp 0x385e
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x37b8
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop