LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/SaadBazaz[P]RIP-Protocol-Simulation/./RoutingTable.h
// Function: TableRow::TableRow(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
TableRow (std::string data, char delimiter = ','){

		auto vec = tokenizeData (data, delimiter);
		// for (int i=0; i<vec.size(); i++){
		// 	std::cout<<vec[i]<<std::endl;
		// }
		identifier = stoi(vec[0]);
		// int client_name;
		fd = stoi(vec[1]);
		status = stoi(vec[2]);
		hop_count = stoi(vec[3]);
		type = vec[4];
		in_use = stoi(vec[5]);
		send_port = stoi(vec[6]);
		receive_port = stoi(vec[7]);
		
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebp
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
leaq 0x20(%rsp), %rdi
callq 0x2250
movsbl %bpl, %edx
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x244c
leaq 0x20(%rsp), %rdi
callq 0x20c0
movq 0x8(%rsp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x3d4b
movl %eax, (%r14)
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x3d4b
movl %eax, 0x4(%r14)
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x3d4b
movw %ax, 0x8(%r14)
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x3d4b
movl %eax, 0xc(%r14)
movq 0x8(%rsp), %rsi
subq $-0x80, %rsi
movq %rbx, %rdi
callq 0x2100
movl $0xa0, %edi
addq 0x8(%rsp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x3d4b
testl %eax, %eax
setne 0x30(%r14)
movl $0xc0, %edi
addq 0x8(%rsp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x3d4b
movl %eax, 0x34(%r14)
movl $0xe0, %edi
addq 0x8(%rsp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x3d4b
movl %eax, 0x38(%r14)
leaq 0x8(%rsp), %rdi
callq 0x3532
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x20c0
jmp 0x3b15
movq %rax, %r14
jmp 0x3b15
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3532
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]optimal-seed-solver/readGenerator.cc
// Function: main
int main(int argc, char* argv[]) {\
	if (argc != 6) {
		cout << "usage: >readGenerator refFile readFile chromoNum readLen readNum" << endl;
		return 1;
	}
	ofstream readFile(argv[2]);

	RefDB refDB;
	refDB.loadRefFile(argv[1]);
	refDB.loadChromo(atoi(argv[3]) );

	int readLen = atoi(argv[4]);
	int readNum = atoi(argv[5]);

	srand(1);
	string read;
	int location;

	for (int i = 0; i < readNum; i++) {
		do {
			location = rand() % (refDB.getChromoLength() - readLen);
			read = refDB.getRefSeq(location, readLen);
		}
		while (read.find('N') != string::npos);

//		cout << location << " "<< read << endl;
		readFile << location << " "<< read << endl;
	}

	readFile.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4d8, %rsp            # imm = 0x4D8
cmpl $0x6, %edi
jne 0x2625
movq %rsi, %r14
movq 0x10(%rsi), %rsi
leaq 0x70(%rsp), %rdi
pushq $0x10
popq %rdx
callq 0x2200
leaq 0x270(%rsp), %rdi
callq 0x27a0
movq 0x8(%r14), %rsi
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x26cc
leaq 0x270(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x2830
leaq 0x30(%rsp), %rdi
callq 0x20f0
movq 0x18(%r14), %rdi
callq 0x22d0
leaq 0x270(%rsp), %rdi
movl %eax, %esi
callq 0x2aa4
movq 0x20(%r14), %rdi
callq 0x22d0
movl %eax, %ebx
movq 0x28(%r14), %rdi
callq 0x22d0
movl %eax, %ebp
pushq $0x1
popq %rdi
callq 0x21b0
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %eax, %eax
testl %ebp, %ebp
cmovlel %eax, %ebp
movl %ebp, 0x4(%rsp)
leaq 0x270(%rsp), %r14
leaq 0x50(%rsp), %r15
leaq 0x10(%rsp), %r12
pushq $0x4e
popq %r13
movq %rax, 0x8(%rsp)
cmpl 0x4(%rsp), %eax
je 0x2645
callq 0x20a0
movl %eax, %ebp
movq %r14, %rdi
callq 0x2c36
movl %eax, %ecx
subl %ebx, %ecx
movl %ebp, %eax
xorl %edx, %edx
divl %ecx
movl %edx, %ebp
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %ecx
callq 0x2c68
movq %r12, %rdi
movq %r15, %rsi
callq 0x2240
movq %r15, %rdi
callq 0x20f0
movq %r12, %rdi
movl %r13d, %esi
xorl %edx, %edx
callq 0x2270
cmpq $-0x1, %rax
jne 0x259d
leaq 0x70(%rsp), %rdi
movl %ebp, %esi
callq 0x2310
movq %rax, %rdi
leaq 0x1a98(%rip), %rsi      # 0x4099
callq 0x21c0
movq %rax, %rdi
movq %r12, %rsi
callq 0x2190
movq %rax, %rdi
callq 0x2100
movq 0x8(%rsp), %rax
incl %eax
jmp 0x258e
movq 0x39a4(%rip), %rdi      # 0x5fd0
leaq 0x19d1(%rip), %rsi      # 0x4004
callq 0x21c0
movq %rax, %rdi
callq 0x2100
pushq $0x1
popq %rax
jmp 0x2672
leaq 0x70(%rsp), %rdi
callq 0x22a0
leaq 0x10(%rsp), %rdi
callq 0x20f0
leaq 0x270(%rsp), %rdi
callq 0x27fe
leaq 0x70(%rsp), %rdi
callq 0x22b0
xorl %eax, %eax
addq $0x4d8, %rsp            # imm = 0x4D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26a0
jmp 0x2692
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x26a8
movq %rax, %rbx
jmp 0x26ad
movq %rax, %rbx
jmp 0x26ba
jmp 0x26a0
jmp 0x26a0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20f0
leaq 0x270(%rsp), %rdi
callq 0x27fe
leaq 0x70(%rsp), %rdi
callq 0x22b0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]optimal-seed-solver/RefDB.cc
// Function: RefDB::loadChromo(int)
bool RefDB::loadChromo(int chromoNum) {
	if (curChromoNum == chromoNum)
			return true;

	curChromoNum = chromoNum;

	cout << "RefDB loading chromosome: " << chromoNum << endl;

	if (chromoNum >= refPos.size())
		return false;

	chromosome.clear();
	refFile.clear();
	refFile.seekg(refPos[chromoNum]);

	getline(refFile, chromoName);

	string temp;

	while (refFile.good() && (temp.size() == 0 || temp[0] != '<')) {
		chromosome.append(temp);
		getline(refFile, temp);
		if (temp[0] == '>') {
			cout << "stop!" << endl;
			break;
		}
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movb $0x1, %bl
cmpl %esi, 0x260(%rdi)
je 0x2be4
movl %esi, %ebp
movq %rdi, %r14
movl %esi, 0x260(%rdi)
movq 0x3500(%rip), %rdi      # 0x5fd0
leaq 0x15c4(%rip), %rsi      # 0x409b
callq 0x21c0
movq %rax, %rdi
movl %ebp, %esi
callq 0x2310
movq %rax, %rdi
callq 0x2100
movslq %ebp, %r12
movq 0x210(%r14), %rax
subq 0x208(%r14), %rax
sarq $0x4, %rax
cmpq %r12, %rax
jbe 0x2be2
andq $0x0, 0x248(%r14)
leaq 0x240(%r14), %r15
movq 0x240(%r14), %rax
xorl %ebp, %ebp
movb %bpl, (%rax)
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x2300
movq 0x208(%r14), %rax
shlq $0x4, %r12
movq (%rax,%r12), %rsi
movq 0x8(%rax,%r12), %rdx
movq %r14, %rdi
callq 0x2250
leaq 0x220(%r14), %rsi
movq %r14, %rdi
callq 0x2050
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %bpl, (%rax)
movq %rsp, %r12
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
jne 0x2bd8
cmpq $0x0, 0x8(%rsp)
setne %al
cmpb $0x3c, %bpl
sete %cl
testb %cl, %al
jne 0x2bd8
movq %r15, %rdi
movq %r12, %rsi
callq 0x2360
movq %r14, %rdi
movq %r12, %rsi
callq 0x2050
movq (%rsp), %rax
movb (%rax), %bpl
cmpb $0x3e, %bpl
jne 0x2b77
movq 0x340c(%rip), %rdi      # 0x5fd0
leaq 0x14eb(%rip), %rsi      # 0x40b6
callq 0x21c0
movq %rax, %rdi
callq 0x2100
movq %rsp, %rdi
callq 0x20f0
jmp 0x2be4
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2bf5
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/CMU-SAFARI[P]optimal-seed-solver/RefDB.cc
// Function: RefDB::getRefSeq[abi:cxx11](unsigned int, unsigned int)
string RefDB::getRefSeq(unsigned int refLoc, unsigned int length) {
	//If oversize, return empty seed.
	if (refLoc >= chromosome.size())
		return string("");

	if (refLoc + length > chromosome.size())
		return (chromosome.substr(refLoc, length)
				+ string(refLoc + length - chromosome.size(), 'N'));

	return chromosome.substr(refLoc, length);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %r14d
movq %rdi, %rbx
movl %edx, %edx
movq 0x248(%rsi), %rax
cmpq %rdx, %rax
jbe 0x2ce5
movq %rsi, %r15
addq $0x240, %rsi            # imm = 0x240
addl %ecx, %r14d
movl %ecx, %ecx
cmpq %r14, %rax
jae 0x2cfb
leaq 0x20(%rsp), %rdi
callq 0x21f0
subq 0x248(%r15), %r14
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq %rsp, %rdi
pushq $0x4e
popq %rdx
movq %r14, %rsi
callq 0x2220
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x2dfd
movq %rsp, %rdi
callq 0x20f0
leaq 0x20(%rsp), %rdi
callq 0x20f0
jmp 0x2d03
leaq 0x13ae(%rip), %rsi      # 0x409a
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x26cc
jmp 0x2d03
movq %rbx, %rdi
callq 0x21f0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20f0
jmp 0x2d20
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/jamesgrimmett[P]orbital_determination/ex10-1_linear_least_squares.cc
// Function: inverse(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>)
std::vector<std::vector<double> > inverse(std::vector<std::vector<double> > arr_) {
  // Calculate the inverse of a 2x2 matrix

  int i, j;
  // tmp variable to store matrix elements
  std::vector<std::vector<double> > inv_ = arr_;
  
  double det_ = determinant(arr_);

  inv_[0][0] = arr_[1][1];
  inv_[1][1] = arr_[0][0];
  inv_[0][1] = -arr_[1][0];
  inv_[1][0] = -arr_[0][1];


  for ( i = 0; i < 2; i++ ) {
    for ( j = 0; j < 2; j++ ) {
      inv_[i][j] = inv_[i][j] / det_;
    }
  }

  return inv_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1a1e
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1a1e
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x198c
movsd %xmm0, (%rsp)
movq %r15, %rdi
callq 0x1a78
movq (%r14), %rcx
movq 0x18(%rcx), %rdx
movsd 0x8(%rdx), %xmm0
movq (%rbx), %rax
movq (%rax), %rsi
movsd %xmm0, (%rsi)
movq (%rcx), %rcx
movsd (%rcx), %xmm0
movq 0x18(%rax), %rdi
movsd %xmm0, 0x8(%rdi)
movsd (%rdx), %xmm0
movapd 0x82c(%rip), %xmm1      # 0x2020
xorpd %xmm1, %xmm0
movlpd %xmm0, 0x8(%rsi)
movsd 0x8(%rcx), %xmm0
xorpd %xmm1, %xmm0
movsd (%rsp), %xmm1
movlpd %xmm0, (%rdi)
xorl %ecx, %ecx
cmpq $0x2, %rcx
je 0x183f
imulq $0x18, %rcx, %rdx
movq (%rax,%rdx), %rdx
xorl %esi, %esi
cmpq $0x2, %rsi
je 0x183a
movsd (%rdx,%rsi,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
jmp 0x1821
incq %rcx
jmp 0x1811
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a78
movq %r14, %rdi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O2/jamesgrimmett[P]orbital_determination/ex10-1_linear_least_squares.cc
// Function: dot_product(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>, std::vector<double, std::allocator<double>>)
std::vector<double> dot_product(std::vector<std::vector<double> > a_, 
                                  std::vector<double> b_) {
  // calculate the dot production of a 2x2 matrix with a 1x2 vector
                          
  std::vector<double> result_ = {0.0, 0.0};
  std::vector<double> a0_ = {a_[0][0], a_[0][1]};
  std::vector<double> a1_ = {a_[1][0], a_[1][1]};

  result_[0] = std::inner_product(a0_.begin(),a0_.end(),b_.begin(),0.0);
  result_[1] = std::inner_product(a1_.begin(),a1_.end(),b_.begin(),0.0);

  return result_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rsi
movaps %xmm0, (%rsi)
pushq $0x2
popq %r12
leaq 0x10(%rsp), %r13
movq %r12, %rdx
movq %r13, %rcx
callq 0x19ae
movq (%r15), %rax
movq (%rax), %rax
movupd (%rax), %xmm0
movapd %xmm0, (%r13)
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x50(%rsp), %rcx
movq %r12, %rdx
callq 0x19ae
movq (%r15), %rax
movq 0x18(%rax), %rax
movupd (%rax), %xmm0
leaq 0x50(%rsp), %rsi
movapd %xmm0, (%rsi)
leaq 0x10(%rsp), %rdi
pushq $0x2
popq %rdx
leaq 0xf(%rsp), %rcx
callq 0x19ae
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rdx
movq (%r14), %rax
xorpd %xmm0, %xmm0
movq %rax, %rsi
cmpq %rdx, %rcx
je 0x1910
movsd (%rcx), %xmm1
mulsd (%rsi), %xmm1
addsd %xmm1, %xmm0
addq $0x8, %rcx
addq $0x8, %rsi
jmp 0x18f5
movq (%rbx), %rcx
movsd %xmm0, (%rcx)
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rsi
xorpd %xmm0, %xmm0
cmpq %rsi, %rdx
je 0x1940
movsd (%rdx), %xmm1
mulsd (%rax), %xmm1
addsd %xmm1, %xmm0
addq $0x8, %rdx
addq $0x8, %rax
jmp 0x1925
movsd %xmm0, 0x8(%rcx)
leaq 0x10(%rsp), %rdi
callq 0x1af2
leaq 0x30(%rsp), %rdi
callq 0x1af2
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x1af2
jmp 0x197c
movq %rax, %r14
movq %rbx, %rdi
callq 0x1af2
movq %r14, %rdi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH01_GettingStarted/examples/add.cc
// Function: main
int main()
{
	// prompt user to enter two numbers
	std::cout << "Enter two numbers:" << std::endl; 
	int v1 = 0, v2 = 0;
	std::cin >> v1 >> v2;   
	std::cout << "The sum of " << v1 << " and " << v2
	          << " is " << v1 + v2 << std::endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x2df3(%rip), %r15      # 0x3fd0
leaq 0xe20(%rip), %rsi       # 0x2004
movq %r15, %rdi
callq 0x1060
movq %rax, %rdi
callq 0x1030
leaq -0x20(%rbp), %rbx
andl $0x0, (%rbx)
leaq -0x1c(%rbp), %r14
andl $0x0, (%r14)
movq 0x2dd6(%rip), %rdi      # 0x3fe0
movq %rbx, %rsi
callq 0x1040
movq %rax, %rdi
movq %r14, %rsi
callq 0x1040
leaq 0xdf3(%rip), %rsi       # 0x2017
movq %r15, %rdi
callq 0x1060
movl (%rbx), %esi
movq %rax, %rdi
callq 0x1080
leaq 0xde6(%rip), %rsi       # 0x2023
movq %rax, %rdi
callq 0x1060
movl (%r14), %esi
movq %rax, %rdi
callq 0x1080
leaq 0xdd2(%rip), %rsi       # 0x2029
movq %rax, %rdi
callq 0x1060
movl (%r14), %esi
addl (%rbx), %esi
movq %rax, %rdi
callq 0x1080
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/m0Mh42[P]mash/./src/main.cpp
// Function: string_to_hex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string string_to_hex(const string& input)
{
    static const char hex_digits[] = "0123456789ABCDEF";

    string output;
    output.reserve(input.length() * 2);
    for (unsigned char c : input)
    {
        output.push_back(hex_digits[c >> 4]);
        output.push_back(hex_digits[c & 15]);
    }
    return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
addq %rsi, %rsi
callq 0x22a0
movq (%r14), %r15
movq 0x8(%r14), %r14
xorl %r12d, %r12d
leaq 0x1c35(%rip), %r13      # 0x4150
cmpq %r12, %r14
je 0x254d
movzbl (%r15,%r12), %ebp
movl %ebp, %eax
shrl $0x4, %eax
movsbl (%rax,%r13), %esi
movq %rbx, %rdi
callq 0x2140
andl $0xf, %ebp
movsbl (%rbp,%r13), %esi
movq %rbx, %rdi
callq 0x2140
incq %r12
jmp 0x251b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2561
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/m0Mh42[P]mash/./src/main.cpp
// Function: check_output(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void check_output(string data){
    if (difficulty > 0){
        for (int i = 0; i < difficulty; i++){
            // If the first characters defined by `difficulty` aren't '0', then we return, as it is false.
            if (data[i] != '0'){
                return;
            }
        }
        // Otherwise, it's the mash we were looking for and we print it, also stop running.
        cout << data << endl;
        run = false;
    } else {
        // There's no difficulty defined, printing the mash and sleeping.
        cout << data << endl;
        usleep(500 * 1000);
    }
}

// Assembly:
pushq %rax
movq %rdi, %rsi
movzbl 0x3c33(%rip), %eax      # 0x61b2
testq %rax, %rax
je 0x259a
movq (%rsi), %rcx
xorl %edx, %edx
cmpq %rdx, %rax
je 0x25b9
cmpb $0x30, (%rcx,%rdx)
leaq 0x1(%rdx), %rdx
je 0x2589
jmp 0x25d4
movq 0x3a2f(%rip), %rdi      # 0x5fd0
callq 0x2170
movq %rax, %rdi
callq 0x20e0
movl $0x7a120, %edi          # imm = 0x7A120
popq %rax
jmp 0x2270
movq 0x3a10(%rip), %rdi      # 0x5fd0
callq 0x2170
movq %rax, %rdi
callq 0x20e0
movb $0x0, 0x3bdf(%rip)      # 0x61b3
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/m0Mh42[P]mash/./src/main.cpp
// Function: difficulty_set(char*)
void difficulty_set(char* difficulty_num){
    try {
        difficulty = stoi(difficulty_num);
    } catch(...) {
        // Not Numeric Difficulty
        cout << "Invalid difficulty. Please insert number as difficulty." << endl;
        exit(USAGEERR);
    }
    if (difficulty > 63){
        // Difficulty can't be 64, so we cant find a result with all the characters '0'
        cout << "Invalid difficulty. Difficulty can\'t be more than 63." << endl;
        exit(INVALIDDIFF);
    }
    cout << "Difficulty set to " << difficulty << endl;
    double probability;
    double x = 64.00 - difficulty;
    // The probability to find the mash we look for.
    probability = pow(16.00, x) / pow(16.00, 64.00);
    cout << "Finding Probability: " << probability << endl;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rsi
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2b88
leaq 0x10(%rsp), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x2b6b
movb %al, 0x3bb0(%rip)       # 0x61b2
leaq 0x10(%rsp), %rdi
callq 0x20d0
cmpb $0x3f, 0x3b9f(%rip)     # 0x61b2
ja 0x26a3
movq 0x39b0(%rip), %rbx      # 0x5fd0
leaq 0x1a77(%rip), %rsi      # 0x409e
movq %rbx, %rdi
callq 0x21b0
movsbl 0x3b7c(%rip), %esi      # 0x61b2
movq %rax, %rdi
callq 0x21f0
movq %rax, %rdi
callq 0x20e0
movzbl 0x3b65(%rip), %eax      # 0x61b2
cvtsi2sd %eax, %xmm1
movsd 0x19af(%rip), %xmm0     # 0x4008
subsd %xmm1, %xmm0
mulsd 0x19ab(%rip), %xmm0     # 0x4010
callq 0x2180
mulsd 0x19a6(%rip), %xmm0     # 0x4018
movsd %xmm0, 0x8(%rsp)
leaq 0x1a32(%rip), %rsi      # 0x40b1
movq %rbx, %rdi
callq 0x21b0
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x22b0
movq %rax, %rdi
callq 0x20e0
addq $0x30, %rsp
popq %rbx
retq
movq 0x3926(%rip), %rdi      # 0x5fd0
leaq 0x19b7(%rip), %rsi      # 0x4068
callq 0x21b0
movq %rax, %rdi
callq 0x20e0
pushq $0x3
jmp 0x26f9
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20d0
jmp 0x26d4
movq %rax, %rbx
movq %rbx, %rdi
callq 0x20b0
movq 0x38ed(%rip), %rdi      # 0x5fd0
leaq 0x1946(%rip), %rsi      # 0x4030
callq 0x21b0
movq %rax, %rdi
callq 0x20e0
pushq $0x2
popq %rdi
callq 0x2210
movq %rax, %rbx
callq 0x22c0
movq %rbx, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x2bc3
// File: /workspace/github_cpp_makefile_star2_O2/m0Mh42[P]mash/./src/mash.cpp
// Function: Mash::mash(MashNode)
MashNode Mash::mash(MashNode node){
    // Random Mash
    xor_random(node);
    
    // Mashing each character round
    for (uint i = 0; i < 16; i++){
        node.value[i] = node.value[i] ^ node.value[32 - i - 1];
    }
    return node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2fc0
pushq $0x10
popq %rcx
xorl %eax, %eax
movq %rcx, %rdx
subq $0x1, %rdx
jb 0x2faa
movq 0x8(%r14), %rsi
movb 0xf(%rsi,%rcx), %cl
xorb %cl, (%rsi,%rax)
incq %rax
movq %rdx, %rcx
jmp 0x2f91
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32e6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/m0Mh42[P]mash/./src/mash.cpp
// Function: Mash::xor_random(MashNode&)
void Mash::xor_random(MashNode& node){
    for (int i = 0; i < 32; i++){
        rand_c_generator();
        node.value[i] ^= VERSION;
        node.value[i] ^= rand_c;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
cmpq $0x20, %r15
je 0x2ff5
callq 0x2090
movb %al, (%r14)
movq 0x8(%rbx), %rax
xorb $0x33, (%rax,%r15)
movb (%r14), %al
movq 0x8(%rbx), %rcx
xorb %al, (%rcx,%r15)
incq %r15
jmp 0x2fce
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/m0Mh42[P]mash/./src/mash.cpp
// Function: Mashtree::init_mashtree(unsigned int)
void Mashtree::init_mashtree(uint chunksize){
    nodetree = new MashNode[chunksize];
    if (nodetree == nullptr){
        cout << memerr;
        exit(MEMERR);
    }
    tree_size = 0;
    k = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r15d
imulq $0x30, %r15, %r14
leaq 0x8(%r14), %rdi
callq 0x2030
movq %r15, (%rax)
leaq 0x8(%rax), %rcx
testl %ebp, %ebp
je 0x307f
addq $0x20, %rax
xorl %edx, %edx
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %dl, (%rax)
movb %dl, 0x10(%rax)
addq $0x30, %rax
addq $-0x30, %r14
jne 0x3067
movq %rcx, 0x20(%rbx)
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/m0Mh42[P]mash/./src/mash.cpp
// Function: Mashtree::mash_k_matching_nodes()
void Mashtree::mash_k_matching_nodes(){
    for (uint i = 0; i < tree_size; i++){
    for (uint n = 0; n < tree_size; n++){
        if (i == n)
            continue;
        if ((nodetree + i)->occupied && (nodetree + n)->occupied){
            if ((nodetree + i)->key == (nodetree + n)->key){
                mash.xor_random(*(nodetree + i));
                mash.xor_random(*(nodetree + n));
                mash.xor_chunks(*(nodetree + i), *(nodetree + n));
                (nodetree + i)->key += 1;
                (nodetree + n)->occupied = false;
                i = 0;
                n = 0;
            }
        }
    }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movl (%rdi), %eax
xorl %ecx, %ecx
cmpl %eax, %ecx
jae 0x31d3
xorl %edx, %edx
cmpl %eax, %edx
jae 0x31cc
cmpl %edx, %ecx
jne 0x315b
movl %ecx, %edx
jmp 0x31c8
movq 0x20(%rbx), %rdi
movl %ecx, %esi
imulq $0x30, %rsi, %r15
cmpb $0x1, 0x28(%rdi,%r15)
jne 0x31c8
movl %edx, %esi
imulq $0x30, %rsi, %r12
cmpb $0x1, 0x28(%rdi,%r12)
jne 0x31c8
leaq (%rdi,%r15), %rsi
addq %r12, %rdi
movzwl (%rsi), %r8d
cmpw (%rdi), %r8w
jne 0x31c8
movq %r14, %rdi
callq 0x2fc0
movq 0x20(%rbx), %rsi
addq %r12, %rsi
movq %r14, %rdi
callq 0x2fc0
movq 0x20(%rbx), %rdx
leaq (%rdx,%r15), %rsi
addq %r12, %rdx
callq 0x2ffc
movq 0x20(%rbx), %rax
incw (%rax,%r15)
movb $0x0, 0x28(%rax,%r12)
movl (%rbx), %eax
xorl %ecx, %ecx
xorl %edx, %edx
incl %edx
jmp 0x314f
incl %ecx
jmp 0x3145
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/m0Mh42[P]mash/./src/file.cpp
// Function: File::open_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void File::open_file(string filename){
    if(file.is_open()){
        file.close();
    }
    if (file.is_open() == false){
        file.open(filename, ios::binary);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x10(%rdi), %r14
addq $0x88, %r15
movq %r15, %rdi
callq 0x2070
testb %al, %al
je 0x336e
movq %r14, %rdi
callq 0x2060
movq %r15, %rdi
callq 0x2070
testb %al, %al
je 0x3380
popq %rbx
popq %r14
popq %r15
retq
pushq $0x4
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O2/m0Mh42[P]mash/./src/file.cpp
// Function: File::read_chunk[abi:cxx11]()
string File::read_chunk() {
    i = 0;
    chunk = "";
    char chr;
    if (file.is_open()){
        while (i < 32){
            if(!is_eof && file.get(chr)){
                chunk.push_back(chr);
                i++;
            } else {
                is_eof = true;
                break;
            }
        }
    }
    if (chunk.length() < 32){
        u_char chr;
        uint8_t len = 32 - chunk.length();
        for (uint8_t i = 0; i < len; i++){
            chr = '0' + len;
            chunk.push_back(chr);
        }
    }
    return chunk;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
andl $0x0, 0x238(%rsi)
leaq 0x218(%rsi), %r14
leaq 0xcf2(%rip), %rsi       # 0x40ce
movq %r14, %rdi
callq 0x2310
leaq 0x88(%r15), %rdi
callq 0x2070
testb %al, %al
je 0x344f
cmpl $0x1f, 0x238(%r15)
jg 0x344f
leaq 0x10(%r15), %r12
leaq 0x7(%rsp), %r13
cmpb $0x0, (%r15)
jne 0x344b
movq %r12, %rdi
movq %r13, %rsi
callq 0x2260
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x344b
movsbl 0x7(%rsp), %esi
movq %r14, %rdi
callq 0x2140
movl 0x238(%r15), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x238(%r15)
cmpl $0x1f, %eax
jl 0x3407
jmp 0x344f
movb $0x1, (%r15)
movq 0x220(%r15), %rax
cmpq $0x1f, %rax
ja 0x3480
movb $0x20, %r15b
subb %al, %r15b
movb $0x50, %cl
subb %al, %cl
xorl %r12d, %r12d
movzbl %cl, %ebp
cmpb %r12b, %r15b
jbe 0x3480
movq %r14, %rdi
movl %ebp, %esi
callq 0x2140
incb %r12b
jmp 0x346c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2250
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/m0Mh42[P]mash/./src/file.cpp
// Function: File::get_file_length()
u_long File::get_file_length(){
    file.seekg(0, ios::end);
    len = file.tellg();
    file.seekg(0, ios::beg);
    return len;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
pushq $0x2
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2240
movq %r14, %rdi
callq 0x22e0
movq %rax, 0x8(%rbx)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2240
movq 0x8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/interimadd[P]M5Stack-PixelArt/test/pixel_art_test.cpp
// Function: (anonymous namespace)::TestPixelArt_CreatePixelArtObj_Test::TestBody()
TEST_F(TestPixelArt, CreatePixelArtObj)
  {
    MonochromePixelArt pixel_art = {
      {1, 0, 0},
      {0, 0, 1}
    };
    EXPECT_EQ(1, pixel_art[0][0]);
    EXPECT_EQ(0, pixel_art[1][1]);
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
leaq 0x8(%rsp), %rsi
movw $0x1, (%rsi)
movb $0x0, 0x2(%rsi)
leaq 0x20(%rsp), %rdi
pushq $0x3
popq %rdx
leaq 0x1f(%rsp), %rcx
callq 0x2795e
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
andw $0x0, (%rsi)
movb $0x1, 0x2(%rsi)
pushq $0x3
popq %rdx
leaq 0x1e(%rsp), %rcx
callq 0x2795e
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
pushq $0x2
popq %rdx
leaq 0x1d(%rsp), %rcx
callq 0x27994
pushq $0x18
popq %rbx
leaq (%rsp,%rbx), %rdi
addq $0x20, %rdi
callq 0x27a48
addq $-0x18, %rbx
cmpq $-0x18, %rbx
jne 0x26fee
leaq 0x8(%rsp), %rcx
movl $0x1, (%rcx)
movq 0x50(%rsp), %rax
movq (%rax), %r8
leaq 0x216f1(%rip), %rsi     # 0x48710
leaq 0x1e0b3(%rip), %rdx     # 0x450d9
leaq 0x20(%rsp), %rdi
callq 0x27cb9
cmpb $0x0, 0x20(%rsp)
jne 0x27091
leaq 0x8(%rsp), %rdi
callq 0x2f572
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x27050
movq (%rax), %r8
jmp 0x27057
leaq 0x20e13(%rip), %r8      # 0x47e6a
leaq 0x1dfc5(%rip), %rdx     # 0x45023
leaq 0x10(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x15
popq %rcx
callq 0x2dddc
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2de5a
leaq 0x10(%rsp), %rdi
callq 0x2de3c
leaq 0x8(%rsp), %rdi
callq 0x27e3a
leaq 0x28(%rsp), %rdi
callq 0x27e80
leaq 0x8(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x50(%rsp), %rax
movq 0x18(%rax), %r8
incq %r8
leaq 0x220a8(%rip), %rsi     # 0x4915e
leaq 0x1e02c(%rip), %rdx     # 0x450e9
leaq 0x20(%rsp), %rdi
callq 0x27cb9
cmpb $0x0, 0x20(%rsp)
jne 0x27128
leaq 0x8(%rsp), %rdi
callq 0x2f572
movq 0x28(%rsp), %rax
testq %rax, %rax
je 0x270e7
movq (%rax), %r8
jmp 0x270ee
leaq 0x20d7c(%rip), %r8      # 0x47e6a
leaq 0x1df2e(%rip), %rdx     # 0x45023
leaq 0x10(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x16
popq %rcx
callq 0x2dddc
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2de5a
leaq 0x10(%rsp), %rdi
callq 0x2de3c
leaq 0x8(%rsp), %rdi
callq 0x27e3a
leaq 0x28(%rsp), %rdi
callq 0x27e80
leaq 0x50(%rsp), %rdi
callq 0x279ce
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x2714a
jmp 0x27159
jmp 0x27168
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2de3c
jmp 0x2715c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x27e3a
jmp 0x2716b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x27e80
jmp 0x2717c
jmp 0x27179
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x279ce
movq %rbx, %rdi
callq 0x25930
movq %rax, %rbx
pushq $0x18
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x20, %rdi
callq 0x27a48
addq $-0x18, %r14
cmpq $-0x18, %r14
jne 0x27195
jmp 0x27186
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x27a48
jmp 0x27186
movq %rax, %rbx
jmp 0x27186
// File: /workspace/github_cpp_makefile_star2_O2/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/include/gtest/gtest.h
// Function: testing::AssertionResult testing::internal::CmpHelperEQ<std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(char const*, char const*, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
AssertionResult CmpHelperEQ(const char* lhs_expression,
                            const char* rhs_expression,
                            const T1& lhs,
                            const T2& rhs) {
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
  if (lhs == rhs) {
    return AssertionSuccess();
  }
GTEST_DISABLE_MSC_WARNINGS_POP_()

  return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %rcx, %rdi
movq %r8, %rsi
callq 0x28206
movq %rbx, %rdi
testb %al, %al
je 0x281e8
callq 0x2f06d
jmp 0x281f9
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x2822f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/include/gtest/gtest.h
// Function: testing::AssertionResult testing::internal::CmpHelperEQFailure<int, unsigned char>(char const*, char const*, int const&, unsigned char const&)
AssertionResult CmpHelperEQFailure(const char* lhs_expression,
                                   const char* rhs_expression,
                                   const T1& lhs, const T2& rhs) {
  return EqFailure(lhs_expression,
                   rhs_expression,
                   FormatForComparisonFailureMessage(lhs, rhs),
                   FormatForComparisonFailureMessage(rhs, lhs),
                   false);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0x27d6f
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x27dd7
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x302df
leaq 0x8(%rsp), %rdi
callq 0x25a68
leaq 0x28(%rsp), %rdi
callq 0x25a68
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x25a68
jmp 0x27d5d
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x25a68
movq %rbx, %rdi
callq 0x25930
// File: /workspace/github_cpp_makefile_star2_O2/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/include/gtest/gtest-printers.h
// Function: void testing::internal::DefaultPrintTo<std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(int, testing::internal::bool_constant<false>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&, std::ostream*)
void DefaultPrintTo(IsContainer /* dummy */,
                    false_type /* is not a pointer */,
                    const C& container, ::std::ostream* os) {
  const size_t kMaxCount = 32;  // The maximum number of elements to print.
  *os << '{';
  size_t count = 0;
  for (typename C::const_iterator it = container.begin();
       it != container.end(); ++it, ++count) {
    if (count > 0) {
      *os << ',';
      if (count == kMaxCount) {  // Enough has been printed.
        *os << " ...";
        break;
      }
    }
    *os << ' ';
    // We cannot call PrintTo(*it, os) here as PrintTo() doesn't
    // handle *it being a native array.
    internal::UniversalPrint(*it, os);
  }

  if (count > 0) {
    *os << ' ';
  }
  *os << '}';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
pushq $0x7b
popq %rsi
movq %rdx, %rdi
callq 0x25590
movq (%r14), %r15
xorl %r13d, %r13d
pushq $0x20
popq %rbp
pushq $0x2c
popq %r12
cmpq 0x8(%r14), %r15
je 0x28410
testq %r13, %r13
je 0x283f2
movq %rbx, %rdi
movl %r12d, %esi
callq 0x25590
cmpq $0x20, %r13
je 0x28417
movq %rbx, %rdi
movl %ebp, %esi
callq 0x25590
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2844a
addq $0x18, %r15
incq %r13
jmp 0x283d6
testq %r13, %r13
jne 0x28426
jmp 0x28431
leaq 0x1fd9b(%rip), %rsi     # 0x481b9
movq %rbx, %rdi
callq 0x25440
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x25590
pushq $0x7d
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x25590
// File: /workspace/github_cpp_makefile_star2_O2/interimadd[P]M5Stack-PixelArt/test/pixel_art_manager_test.cpp
// Function: (anonymous namespace)::TestPixelArtManager::SetUp()
void SetUp(){
        const int kLCDHorizontalPixelNum = 6;
        const int kLCDVerticalPixelNum = 4;
        lcd = new LCDController(kLCDHorizontalPixelNum, kLCDVerticalPixelNum);
        mng = new PixelArtManager(lcd);
        lcd_small = new LCDController(1, 1);
        mng_small = new PixelArtManager(lcd_small);
      }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x25460
movq %rax, %r14
pushq $0x6
popq %rsi
pushq $0x4
popq %rdx
movq %rax, %rdi
callq 0x2d27c
movq %r14, 0x10(%rbx)
pushq $0x30
popq %rdi
callq 0x25460
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x2d410
movq %r15, 0x18(%rbx)
pushq $0x20
popq %rdi
callq 0x25460
movq %rax, %r14
pushq $0x1
popq %rdx
movq %rax, %rdi
movl %edx, %esi
callq 0x2d27c
movq %r14, 0x20(%rbx)
pushq $0x30
popq %rdi
callq 0x25460
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x2d410
movq %r15, 0x28(%rbx)
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2867d
jmp 0x28688
movq %rax, %rbx
pushq $0x30
popq %rsi
movq %r15, %rdi
jmp 0x28691
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x25490
movq %rbx, %rdi
callq 0x25930
// File: /workspace/github_cpp_makefile_star2_O2/interimadd[P]M5Stack-PixelArt/test/pixel_art_manager_test.cpp
// Function: (anonymous namespace)::TestPixelArtManager_InitPixelArtManager_Test::TestBody()
TEST_F(TestPixelArtManager, InitPixelArtManager)
  {
    LCDState expect = {
      {0, 0, 0, 0, 0, 0},
      {0, 0, 0, 0, 0, 0},
      {0, 0, 0, 0, 0, 0},
      {0, 0, 0, 0, 0, 0}
    };
    EXPECT_EQ(expect, lcd->getState());
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
leaq 0x18(%rsp), %rsi
andw $0x0, 0x4(%rsi)
movq %rdi, %rbx
andl $0x0, (%rsi)
leaq 0x50(%rsp), %r14
pushq $0x6
popq %rdx
leaq 0xf(%rsp), %rcx
movq %r14, %rdi
callq 0x2795e
leaq 0x10(%rsp), %rsi
andw $0x0, 0x4(%rsi)
leaq 0x68(%rsp), %r15
andl $0x0, (%rsi)
pushq $0x6
popq %rdx
leaq 0xe(%rsp), %rcx
movq %r15, %rdi
callq 0x2795e
leaq 0x48(%rsp), %rsi
andw $0x0, 0x4(%rsi)
leaq 0x80(%rsp), %r15
andl $0x0, (%rsi)
pushq $0x6
popq %rdx
leaq 0xd(%rsp), %rcx
movq %r15, %rdi
callq 0x2795e
leaq 0x40(%rsp), %rsi
andw $0x0, 0x4(%rsi)
leaq 0x98(%rsp), %r15
andl $0x0, (%rsi)
pushq $0x6
popq %rdx
leaq 0xc(%rsp), %rcx
movq %r15, %rdi
callq 0x2795e
leaq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rsi
pushq $0x4
popq %rdx
leaq 0xb(%rsp), %rcx
callq 0x27994
pushq $0x48
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x50, %rdi
callq 0x27a48
addq $-0x18, %r14
cmpq $-0x18, %r14
jne 0x28758
movq 0x10(%rbx), %rsi
leaq 0x50(%rsp), %rdi
callq 0x27ed2
leaq 0x1cd67(%rip), %rsi     # 0x454eb
leaq 0x1cd67(%rip), %rdx     # 0x454f2
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rcx
leaq 0x50(%rsp), %r8
callq 0x281b7
leaq 0x50(%rsp), %rdi
callq 0x279ce
cmpb $0x0, 0x18(%rsp)
jne 0x2880a
leaq 0x50(%rsp), %rdi
callq 0x2f572
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x287c9
movq (%rax), %r8
jmp 0x287d0
leaq 0x1f69a(%rip), %r8      # 0x47e6a
leaq 0x1cbea(%rip), %rdx     # 0x453c1
leaq 0x10(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x23
popq %rcx
callq 0x2dddc
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2de5a
leaq 0x10(%rsp), %rdi
callq 0x2de3c
leaq 0x50(%rsp), %rdi
callq 0x27e3a
leaq 0x20(%rsp), %rdi
callq 0x27e80
leaq 0x28(%rsp), %rdi
callq 0x279ce
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2de3c
jmp 0x2883d
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x27e3a
jmp 0x2884c
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x27e80
jmp 0x2886a
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x279ce
jmp 0x2886a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x279ce
jmp 0x288b3
movq %rax, %rbx
pushq $0x48
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x50, %rdi
callq 0x27a48
addq $-0x18, %r14
cmpq $-0x18, %r14
jne 0x2887d
jmp 0x288b3
jmp 0x2889a
jmp 0x2889a
movq %rax, %rbx
addq $-0x18, %r15
movq %r15, %rdi
callq 0x27a48
cmpq %r14, %r15
jne 0x2889d
jmp 0x288b3
movq %rax, %rbx
movq %rbx, %rdi
callq 0x25930
nop
// File: /workspace/github_cpp_makefile_star2_O2/interimadd[P]M5Stack-PixelArt/test/pixel_art_manager_test.cpp
// Function: (anonymous namespace)::TestPixelArtManager_DrawNullPixelFrameDoNotChangeLCD_Test::TestBody()
TEST_F(TestPixelArtManager, DrawNullPixelFrameDoNotChangeLCD)
  {
    OperationType no_op = OperationType::NO_OPERATION;
    mng_small->drawNextFrame(no_op);
    LCDState expect = {{0}};
    EXPECT_EQ(expect, lcd_small->getState());
  }

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
xorl %esi, %esi
callq 0x2d532
leaq 0x28(%rsp), %rsi
movb $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
pushq $0x1
popq %rdx
leaq 0x8(%rsp), %rcx
callq 0x2795e
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0x7(%rsp), %rcx
callq 0x27994
leaq 0x10(%rsp), %rdi
callq 0x27a48
movq 0x20(%rbx), %rsi
leaq 0x10(%rsp), %rdi
callq 0x27ed2
leaq 0x1bf44(%rip), %rsi     # 0x454eb
leaq 0x1bf61(%rip), %rdx     # 0x4550f
leaq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x281b7
leaq 0x10(%rsp), %rdi
callq 0x279ce
cmpb $0x0, 0x28(%rsp)
jne 0x2962d
leaq 0x10(%rsp), %rdi
callq 0x2f572
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x295ec
movq (%rax), %r8
jmp 0x295f3
leaq 0x1e877(%rip), %r8      # 0x47e6a
leaq 0x1bdc7(%rip), %rdx     # 0x453c1
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x68
popq %rcx
callq 0x2dddc
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2de5a
leaq 0x8(%rsp), %rdi
callq 0x2de3c
leaq 0x10(%rsp), %rdi
callq 0x27e3a
leaq 0x30(%rsp), %rdi
callq 0x27e80
leaq 0x38(%rsp), %rdi
callq 0x279ce
addq $0x50, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2de3c
jmp 0x29659
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x27e3a
jmp 0x29668
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x27e80
jmp 0x29686
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x279ce
jmp 0x29686
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x279ce
jmp 0x296a4
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x27a48
jmp 0x296a4
movq %rax, %rbx
movq %rbx, %rdi
callq 0x25930
// File: /workspace/github_cpp_makefile_star2_O2/interimadd[P]M5Stack-PixelArt/test/lcd_mock_test.cpp
// Function: (anonymous namespace)::TestLCDMock_LCDisWhiteWhenInitilize_Test::TestBody()
TEST_F(TestLCDMock, LCDisWhiteWhenInitilize)
  {
    LCDState expect_state = {
      {0, 0, 0},
      {0, 0, 0}
    };
    EXPECT_EQ(expect_state, lcd->getState());
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rsi
andw $0x0, (%rsi)
movb $0x0, 0x2(%rsi)
leaq 0x20(%rsp), %rdi
pushq $0x3
popq %rdx
leaq 0x7(%rsp), %rcx
callq 0x2795e
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
andw $0x0, (%rsi)
movb $0x0, 0x2(%rsi)
pushq $0x3
popq %rdx
leaq 0x6(%rsp), %rcx
callq 0x2795e
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
pushq $0x2
popq %rdx
leaq 0x5(%rsp), %rcx
callq 0x27994
pushq $0x18
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x20, %rdi
callq 0x27a48
addq $-0x18, %r14
cmpq $-0x18, %r14
jne 0x2aa09
movq 0x10(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x27ed2
leaq 0x1aacd(%rip), %rsi     # 0x45502
leaq 0x1aab6(%rip), %rdx     # 0x454f2
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rcx
leaq 0x20(%rsp), %r8
callq 0x281b7
leaq 0x20(%rsp), %rdi
callq 0x279ce
cmpb $0x0, 0x10(%rsp)
jne 0x2aabb
leaq 0x20(%rsp), %rdi
callq 0x2f572
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x2aa7a
movq (%rax), %r8
jmp 0x2aa81
leaq 0x1d3e9(%rip), %r8      # 0x47e6a
leaq 0x1b16f(%rip), %rdx     # 0x45bf7
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x18
popq %rcx
callq 0x2dddc
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2de5a
leaq 0x8(%rsp), %rdi
callq 0x2de3c
leaq 0x20(%rsp), %rdi
callq 0x27e3a
leaq 0x18(%rsp), %rdi
callq 0x27e80
leaq 0x50(%rsp), %rdi
callq 0x279ce
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2de3c
jmp 0x2aae9
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x27e3a
jmp 0x2aaf8
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x27e80
jmp 0x2ab16
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x279ce
jmp 0x2ab16
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x279ce
jmp 0x2ab54
movq %rax, %rbx
pushq $0x18
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x20, %rdi
callq 0x27a48
addq $-0x18, %r14
cmpq $-0x18, %r14
jne 0x2ab29
jmp 0x2ab54
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x27a48
jmp 0x2ab54
movq %rax, %rbx
movq %rbx, %rdi
callq 0x25930
// File: /workspace/github_cpp_makefile_star2_O2/interimadd[P]M5Stack-PixelArt/test/lcd_mock_test.cpp
// Function: (anonymous namespace)::TestLCDMock_FillRectBlack_Test::TestBody()
TEST_F(TestLCDMock, FillRectBlack)
  {
    int v_pos = 0, h_pos = 1;
    int v_len = 2, h_len = 1;
    lcd->fillRect(v_pos, h_pos, v_len, h_len, 1);
    LCDState expect_state = {
      {0, 1, 0},
      {0, 1, 0}
    };
    EXPECT_EQ(expect_state, lcd->getState());
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
pushq $0x2
popq %rcx
pushq $0x1
popq %rdx
xorl %esi, %esi
movl %edx, %r8d
movl %edx, %r9d
callq 0x2d322
leaq 0x10(%rsp), %rsi
movw $0x100, (%rsi)          # imm = 0x100
movb $0x0, 0x2(%rsi)
leaq 0x20(%rsp), %rdi
pushq $0x3
popq %rdx
leaq 0x7(%rsp), %rcx
callq 0x2795e
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movw $0x100, (%rsi)          # imm = 0x100
movb $0x0, 0x2(%rsi)
pushq $0x3
popq %rdx
leaq 0x6(%rsp), %rcx
callq 0x2795e
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
pushq $0x2
popq %rdx
leaq 0x5(%rsp), %rcx
callq 0x27994
pushq $0x18
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x20, %rdi
callq 0x27a48
addq $-0x18, %r14
cmpq $-0x18, %r14
jne 0x2ac3a
movq 0x10(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x27ed2
leaq 0x1a89c(%rip), %rsi     # 0x45502
leaq 0x1a885(%rip), %rdx     # 0x454f2
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rcx
leaq 0x20(%rsp), %r8
callq 0x281b7
leaq 0x20(%rsp), %rdi
callq 0x279ce
cmpb $0x0, 0x10(%rsp)
jne 0x2acec
leaq 0x20(%rsp), %rdi
callq 0x2f572
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x2acab
movq (%rax), %r8
jmp 0x2acb2
leaq 0x1d1b8(%rip), %r8      # 0x47e6a
leaq 0x1af3e(%rip), %rdx     # 0x45bf7
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x24
popq %rcx
callq 0x2dddc
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2de5a
leaq 0x8(%rsp), %rdi
callq 0x2de3c
leaq 0x20(%rsp), %rdi
callq 0x27e3a
leaq 0x18(%rsp), %rdi
callq 0x27e80
leaq 0x50(%rsp), %rdi
callq 0x279ce
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2de3c
jmp 0x2ad1a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x27e3a
jmp 0x2ad29
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x27e80
jmp 0x2ad47
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x279ce
jmp 0x2ad47
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x279ce
jmp 0x2ad85
movq %rax, %rbx
pushq $0x18
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x20, %rdi
callq 0x27a48
addq $-0x18, %r14
cmpq $-0x18, %r14
jne 0x2ad5a
jmp 0x2ad85
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x27a48
jmp 0x2ad85
movq %rax, %rbx
movq %rbx, %rdi
callq 0x25930
nop
// File: /workspace/github_cpp_makefile_star2_O2/interimadd[P]M5Stack-PixelArt/test/lcd_mock_test.cpp
// Function: (anonymous namespace)::TestLCDMock_FillRectBlackAll_Test::TestBody()
TEST_F(TestLCDMock, FillRectBlackAll)
  {
    int v_pos = 0, h_pos = 0;
    int v_len = 2, h_len = 3;
    lcd->fillRect(v_pos, h_pos, v_len, h_len, 1);
    LCDState expect_state = {
      {1, 1, 1},
      {1, 1, 1}
    };
    EXPECT_EQ(expect_state, lcd->getState());
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
pushq $0x2
popq %rcx
pushq $0x3
popq %r8
pushq $0x1
popq %r9
xorl %esi, %esi
xorl %edx, %edx
callq 0x2d322
leaq 0x10(%rsp), %rsi
movw $0x101, (%rsi)          # imm = 0x101
movb $0x1, 0x2(%rsi)
leaq 0x20(%rsp), %rdi
pushq $0x3
popq %rdx
leaq 0x7(%rsp), %rcx
callq 0x2795e
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movw $0x101, (%rsi)          # imm = 0x101
movb $0x1, 0x2(%rsi)
pushq $0x3
popq %rdx
leaq 0x6(%rsp), %rcx
callq 0x2795e
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
pushq $0x2
popq %rdx
leaq 0x5(%rsp), %rcx
callq 0x27994
pushq $0x18
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x20, %rdi
callq 0x27a48
addq $-0x18, %r14
cmpq $-0x18, %r14
jne 0x2ae6b
movq 0x10(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x27ed2
leaq 0x1a66b(%rip), %rsi     # 0x45502
leaq 0x1a654(%rip), %rdx     # 0x454f2
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rcx
leaq 0x20(%rsp), %r8
callq 0x281b7
leaq 0x20(%rsp), %rdi
callq 0x279ce
cmpb $0x0, 0x10(%rsp)
jne 0x2af1d
leaq 0x20(%rsp), %rdi
callq 0x2f572
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x2aedc
movq (%rax), %r8
jmp 0x2aee3
leaq 0x1cf87(%rip), %r8      # 0x47e6a
leaq 0x1ad0d(%rip), %rdx     # 0x45bf7
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x30
popq %rcx
callq 0x2dddc
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2de5a
leaq 0x8(%rsp), %rdi
callq 0x2de3c
leaq 0x20(%rsp), %rdi
callq 0x27e3a
leaq 0x18(%rsp), %rdi
callq 0x27e80
leaq 0x50(%rsp), %rdi
callq 0x279ce
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2de3c
jmp 0x2af4b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x27e3a
jmp 0x2af5a
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x27e80
jmp 0x2af78
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x279ce
jmp 0x2af78
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x279ce
jmp 0x2afb6
movq %rax, %rbx
pushq $0x18
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x20, %rdi
callq 0x27a48
addq $-0x18, %r14
cmpq $-0x18, %r14
jne 0x2af8b
jmp 0x2afb6
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x27a48
jmp 0x2afb6
movq %rax, %rbx
movq %rbx, %rdi
callq 0x25930