LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/SaadBazaz[P]RIP-Protocol-Simulation/./RoutingTable.h
// Function: serialize[abi:cxx11](std::vector<TableRow, std::allocator<TableRow>>&)
std::string serialize (std::vector<TableRow> &table){
	std::string returnTo;
	for (int i=0; i<table.size(); i++){
		returnTo += table[i].toString();
		if (i+1 != table.size())
			returnTo += '\n';
	}
	return returnTo;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rsi
cmpq %rsi, 0x8(%r14)
je 0x26ed
leaq 0x18(%rsp), %r13
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
xorl %r12d, %r12d
addq %rbp, %rsi
movq %r15, %rdi
movl $0x2c, %edx
callq 0x43fc
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2080
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x26b3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
incq %r12
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x6, %rax
cmpq %rax, %r12
je 0x26e4
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x6, %rax
addq $0x40, %rbp
cmpq %r12, %rax
ja 0x267a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2701
movq %rax, %r14
jmp 0x2720
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2720
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x2738
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2200
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/SaadBazaz[P]RIP-Protocol-Simulation/./RoutingTable.h
// Function: deserialize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<TableRow> deserialize (std::string table_string){
	std::vector <std::string> rows = tokenizeData(table_string, '\n');

	std::vector<TableRow> returnTo; 

	for (int i=0; i<rows.size(); i++){
		TableRow new_row (rows[i]);
		returnTo.push_back(new_row);
	}

	return returnTo;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x48(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x5d4e
movq %rsp, %rdi
movq %r14, %rsi
movl $0xa, %edx
callq 0x249c
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x279e
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x2200
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x2859
leaq 0x28(%rsp), %r12
movl $0x8, %ebp
xorl %r13d, %r13d
leaq 0x18(%rsp), %r14
leaq 0x58(%rsp), %r15
movq %r12, 0x18(%rsp)
movq -0x8(%rax,%rbp), %rsi
movq (%rax,%rbp), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x5d4e
movq %r15, %rdi
movq %r14, %rsi
movl $0x2c, %edx
callq 0x55a0
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x2812
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5a24
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x2839
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2200
incq %r13
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %rbp
cmpq %r13, %rcx
ja 0x27d2
movq %rsp, %rdi
callq 0x439e
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x38(%rsp), %rdi
cmpq %r15, %rdi
je 0x28da
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x28da
movq %rax, %r14
jmp 0x28ca
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x28ca
movq 0x28(%rsp), %rsi
jmp 0x28c2
movq %rax, %r14
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x28ca
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x5a8a
movq %rsp, %rdi
callq 0x439e
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movb $0x1, %bl
cmpl %esi, 0x260(%rdi)
je 0x2f13
movl %esi, %ebp
movq %rdi, %r14
movl %esi, 0x260(%rdi)
movq 0x3278(%rip), %r15      # 0x5fd0
leaq 0x133c(%rip), %rsi      # 0x409b
movl $0x1a, %edx
movq %r15, %rdi
callq 0x2240
movq %r15, %rdi
movl %ebp, %esi
callq 0x2310
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movslq %ebp, %r12
movq 0x210(%r14), %rax
subq 0x208(%r14), %rax
sarq $0x4, %rax
cmpq %r12, %rax
jbe 0x2f11
leaq 0x240(%r14), %r15
xorl %ebp, %ebp
movq %rbp, 0x248(%r14)
movq 0x240(%r14), %rax
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 0x2280
leaq 0x220(%r14), %r12
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2350
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rbp, -0x8(%r13)
movb %bpl, (%r13)
leaq 0x8(%rsp), %r12
movq %r13, %rsi
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r14,%rax)
jne 0x2ef7
movq 0x10(%rsp), %rdx
testq %rdx, %rdx
setne %al
cmpb $0x3c, %bpl
sete %cl
testb %cl, %al
jne 0x2ef7
movq %r15, %rdi
callq 0x20b0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2350
movq 0x8(%rsp), %rsi
movb (%rsi), %bpl
cmpb $0x3e, %bpl
jne 0x2e47
movq 0x311d(%rip), %r14      # 0x5fd0
leaq 0x11fc(%rip), %rsi      # 0x40b6
movl $0x5, %edx
movq %r14, %rdi
callq 0x2240
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq 0x30eb(%rip), %rdi      # 0x5fd0
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq 0x8(%rsp), %rsi
cmpq %r13, %rsi
je 0x2f13
movq 0x18(%rsp), %rax
incq %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x21f0
jmp 0x2f13
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f26
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2f40
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3071
movq %rsi, %r15
addq $0x240, %rsi            # imm = 0x240
addl %ecx, %r14d
movl %ecx, %ecx
cmpq %r14, %rax
jae 0x308f
leaq 0x20(%rsp), %rdi
callq 0x2200
subq 0x248(%r15), %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rsp, %rdi
movq %r14, %rsi
movl $0x4e, %edx
callq 0x2250
leaq 0x30(%rsp), %r14
movq -0x10(%r14), %rcx
movq -0x8(%r14), %r8
movq 0x8(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r14, %rcx
je 0x3048
movq 0x30(%rsp), %rdi
movq (%rsp), %rsi
cmpq %rdi, %rax
jbe 0x3065
movl $0xf, %edi
cmpq %r15, %rsi
je 0x3060
movq 0x10(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x3099
leaq 0x20(%rsp), %rdi
callq 0x20b0
jmp 0x30a5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x101b(%rip), %rdx      # 0x409a
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x27f0
jmp 0x3113
movq %rbx, %rdi
callq 0x2200
jmp 0x3113
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2220
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x30c4
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x30ca
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x30fc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x3113
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x313e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x313e
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3159
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1cca
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x1cca
leaq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq (%rax), %rcx
movq 0x18(%rax), %rax
movsd (%rax), %xmm0
mulsd 0x8(%rcx), %xmm0
movsd (%rcx), %xmm1
mulsd 0x8(%rax), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, (%rsp)
callq 0x1d64
movq (%r14), %rax
movq 0x18(%rax), %rcx
movsd 0x8(%rcx), %xmm0
movq (%rbx), %rdx
movq (%rdx), %rsi
movsd %xmm0, (%rsi)
movq (%rax), %rax
movsd (%rax), %xmm0
movq 0x18(%rdx), %rdi
movsd %xmm0, 0x8(%rdi)
movsd (%rcx), %xmm0
movaps 0x15c5(%rip), %xmm1     # 0x3020
xorps %xmm1, %xmm0
movlps %xmm0, 0x8(%rsi)
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm0
movlps %xmm0, (%rdi)
movq (%rdx), %rax
movupd (%rax), %xmm0
movapd (%rsp), %xmm1
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
divpd %xmm1, %xmm0
movupd %xmm0, (%rax)
movq 0x18(%rdx), %rax
movupd (%rax), %xmm0
divpd %xmm1, %xmm0
movupd %xmm0, (%rax)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1d64
movq %r14, %rdi
callq 0x1140
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x30(%rsp), %r12
movl $0x2, %edx
movq %r12, %rcx
callq 0x1c3a
movq (%r15), %rax
movq (%rax), %rax
movupd (%rax), %xmm0
movapd %xmm0, (%r12)
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x50(%rsp), %rcx
movl $0x2, %edx
callq 0x1c3a
movq (%r15), %rax
movq 0x18(%rax), %rax
movupd (%rax), %xmm0
leaq 0x50(%rsp), %rsi
movapd %xmm0, (%rsi)
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movl $0x2, %edx
callq 0x1c3a
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
movq (%r14), %rax
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
cmpq %rdx, %rcx
je 0x1b6b
movq %rax, %rsi
movsd (%rcx), %xmm2
mulsd (%rsi), %xmm2
addsd %xmm2, %xmm1
addq $0x8, %rcx
addq $0x8, %rsi
cmpq %rdx, %rcx
jne 0x1b52
movq (%rbx), %rcx
movsd %xmm1, (%rcx)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rdx
cmpq %rdx, %rdi
je 0x1ba1
xorpd %xmm0, %xmm0
movq %rdi, %rsi
movsd (%rsi), %xmm1
mulsd (%rax), %xmm1
addsd %xmm1, %xmm0
addq $0x8, %rsi
addq $0x8, %rax
cmpq %rdx, %rsi
jne 0x1b88
movsd %xmm0, 0x8(%rcx)
testq %rdi, %rdi
je 0x1bb8
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x10d0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bcf
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10d0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1bfd
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x10d0
jmp 0x1bfd
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1c11
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x10d0
movq %r14, %rdi
callq 0x1140
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movzbl 0x3be9(%rip), %eax      # 0x61b2
movq (%rdi), %rsi
testq %rax, %rax
je 0x2624
xorl %ecx, %ecx
cmpb $0x30, (%rsi,%rcx)
jne 0x2622
incq %rcx
cmpq %rcx, %rax
jne 0x25d3
movq 0x8(%rdi), %rdx
movq 0x39ec(%rip), %rdi      # 0x5fd8
callq 0x2200
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
movb $0x0, 0x3b91(%rip)      # 0x61b3
popq %rbx
retq
movq 0x8(%rdi), %rdx
movq 0x39a9(%rip), %rdi      # 0x5fd8
callq 0x2200
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
movl $0x7a120, %edi          # imm = 0x7A120
popq %rbx
jmp 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x33ea
movl $0x1f, %eax
xorl %ecx, %ecx
movq 0x8(%rbx), %rdx
movb (%rdx,%rax), %sil
xorb %sil, (%rdx,%rcx)
incq %rcx
decq %rax
cmpq $0x10, %rcx
jne 0x3378
movzwl (%rbx), %eax
movw %ax, (%r14)
leaq 0x18(%r14), %rcx
movq %rcx, 0x8(%r14)
movq 0x8(%rbx), %rdx
leaq 0x18(%rbx), %rax
cmpq %rax, %rdx
je 0x33b9
movq %rdx, 0x8(%r14)
movq (%rax), %rcx
movq %rcx, 0x18(%r14)
jmp 0x33bf
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%r14)
movq %rax, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movb $0x0, 0x18(%rbx)
movb 0x28(%rbx), %al
movb %al, 0x28(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %r15, %r14
shlq $0x4, %r14
leaq (%r14,%r14,2), %rdi
addq $0x8, %rdi
callq 0x2030
movq %r15, (%rax)
leaq 0x8(%rax), %rcx
testl %ebp, %ebp
je 0x34b5
addq $0x20, %rax
leaq (%r14,%r14,2), %rdx
xorl %esi, %esi
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb %sil, (%rax)
movb %sil, 0x10(%rax)
addq $0x30, %rax
addq $-0x30, %rdx
jne 0x3498
movq %rcx, 0x20(%rbx)
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/m0Mh42[P]mash/./src/mash.cpp
// Function: Mashtree::add_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Mashtree::add_node(const string& value){
    MashNode node;
    node.key = 0;
    node.value = value;
    node.occupied = true;
    for (uint i = 0; i <= tree_size; i++){
        if ((nodetree + i)->occupied == false){
            *(nodetree + i) = node;
            tree_size++;
            return true;
        }
    }
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
xorl %r13d, %r13d
movb %r13b, (%r15)
movb %r13b, 0x10(%r15)
movw $0x0, -0x18(%r15)
movq %r14, %rdi
callq 0x20f0
movb $0x1, 0x30(%rsp)
movl (%rbx), %eax
movq 0x20(%rbx), %r12
movl %r13d, %ecx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movb 0x28(%r12,%rcx), %bpl
testb %bpl, %bpl
je 0x3536
incl %r13d
cmpl %eax, %r13d
jbe 0x3517
jmp 0x355b
addq %rcx, %r12
movzwl 0x8(%rsp), %eax
movw %ax, (%r12)
leaq 0x8(%r12), %rdi
movq %r14, %rsi
callq 0x20f0
movb 0x30(%rsp), %al
movb %al, 0x28(%r12)
incl (%rbx)
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x3572
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21e0
testb %bpl, %bpl
sete %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3589
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x35a3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl (%rdi), %eax
testl %eax, %eax
je 0x36a4
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
xorl %edx, %edx
xorl %ecx, %ecx
cmpl %edx, %ecx
jne 0x35d5
movl %edx, %ecx
jmp 0x3682
movq 0x20(%rbx), %rdi
movl %ecx, %esi
leaq (%rsi,%rsi,2), %r15
shlq $0x4, %r15
cmpb $0x1, 0x28(%rdi,%r15)
jne 0x3682
movl %edx, %r13d
leaq (,%r13,2), %r12
addq %r13, %r12
shlq $0x4, %r12
cmpb $0x1, 0x28(%rdi,%r12)
jne 0x3682
leaq (%rdi,%r15), %rsi
addq %r12, %rdi
movzwl (%rsi), %r8d
cmpw (%rdi), %r8w
jne 0x3682
movq %r14, %rdi
callq 0x33ea
shlq $0x4, %r13
leaq (%r13,%r13,2), %r13
movq 0x20(%rbx), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0x33ea
movq 0x20(%rbx), %rcx
leaq (%rcx,%r15), %rax
addq $0x8, %rax
addq %r13, %rcx
addq $0x8, %rcx
xorl %edx, %edx
movq (%rax), %rsi
xorb $0x33, (%rsi,%rdx)
movq (%rcx), %rsi
movb (%rsi,%rdx), %sil
movq (%rax), %rdi
xorb %sil, (%rdi,%rdx)
incq %rdx
cmpq $0x20, %rdx
jne 0x364f
movq 0x20(%rbx), %rax
incw (%rax,%r15)
movb $0x0, 0x28(%rax,%r12)
movl (%rbx), %eax
xorl %ecx, %ecx
xorl %edx, %edx
incl %edx
cmpl %eax, %edx
jb 0x35ca
incl %ecx
movl $0x0, %edx
cmpl %eax, %ecx
jb 0x35ca
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2080
testb %al, %al
je 0x3876
movq %r14, %rdi
callq 0x2070
movq %r15, %rdi
callq 0x2080
testb %al, %al
je 0x3888
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
movl $0x4, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x2160
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x0, 0x238(%rsi)
leaq 0x218(%rsi), %r14
movq 0x220(%rsi), %rdx
leaq 0x7de(%rip), %rcx       # 0x40ce
movq %r14, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x22a0
leaq 0x88(%r15), %rdi
callq 0x2080
testb %al, %al
je 0x3968
cmpl $0x1f, 0x238(%r15)
jg 0x3968
leaq 0x10(%r15), %r12
leaq 0x7(%rsp), %r13
cmpb $0x0, (%r15)
jne 0x3964
movq %r12, %rdi
movq %r13, %rsi
callq 0x2250
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3964
movsbl 0x7(%rsp), %esi
movq %r14, %rdi
callq 0x2150
movl 0x238(%r15), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x238(%r15)
cmpl $0x1f, %eax
jl 0x3920
jmp 0x3968
movb $0x1, (%r15)
movq 0x220(%r15), %rdx
cmpq $0x1f, %rdx
ja 0x399e
movb $0x20, %r12b
subb %dl, %r12b
movb $0x50, %al
subb %dl, %al
xorl %r13d, %r13d
movzbl %al, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x2150
incb %r13b
cmpb %r13b, %r12b
ja 0x3985
movq 0x220(%r15), %rdx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3046
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_O3/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 0x8(%rcx), %rsi
movq %rsi, %rax
subq %rdi, %rax
movq (%r8), %rdx
movq 0x8(%r8), %rcx
subq %rdx, %rcx
cmpq %rcx, %rax
jne 0x2122e
callq 0x21326
testb %al, %al
je 0x2122e
movq %rbx, %rdi
callq 0x294eb
jmp 0x21242
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x2124f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20d80
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x20e03
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x2aec2
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20d10
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20d2b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20d5d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x20d5d
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20d78
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x5(%rsp), %rsi
movb $0x7b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1d540
movq (%r14), %r15
cmpq 0x8(%r14), %r15
je 0x214d0
xorl %ebp, %ebp
leaq 0x4(%rsp), %r12
leaq 0x3(%rsp), %r13
testq %rbp, %rbp
je 0x21471
movb $0x2c, 0x3(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1d540
cmpq $0x20, %rbp
je 0x214a7
movb $0x20, 0x4(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1d540
xorl %edi, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x214f4
addq $0x18, %r15
incq %rbp
cmpq 0x8(%r14), %r15
jne 0x21451
testq %rbp, %rbp
jne 0x214bb
jmp 0x214d0
leaq 0x2ad3b(%rip), %rsi     # 0x4c1e9
movl $0x4, %edx
movq %rbx, %rdi
callq 0x1d540
leaq 0x6(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1d540
leaq 0x7(%rsp), %rsi
movb $0x7d, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1d540
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x20, %edi
callq 0x1d430
movq %rax, %r14
movq %rax, %rdi
movl $0x6, %esi
movl $0x4, %edx
callq 0x26d8c
movq %r14, 0x10(%rbx)
movl $0x30, %edi
callq 0x1d430
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x26f58
movq %r15, 0x18(%rbx)
movl $0x20, %edi
callq 0x1d430
movq %rax, %r14
movq %rax, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x26d8c
movq %r14, 0x20(%rbx)
movl $0x30, %edi
callq 0x1d430
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x26f58
movq %r15, 0x28(%rbx)
popq %rbx
popq %r14
popq %r15
retq
jmp 0x216d8
jmp 0x216e5
movq %rax, %rbx
movl $0x30, %esi
movq %r15, %rdi
jmp 0x216f0
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x1d460
movq %rbx, %rdi
callq 0x1d900
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdi, %rbx
leaq 0x18(%rsp), %rsi
movw $0x0, 0x4(%rsi)
movl $0x0, (%rsi)
leaq 0x28(%rsp), %r14
leaq 0xf(%rsp), %rcx
movl $0x6, %edx
movq %r14, %rdi
callq 0x2093a
leaq 0x40(%rsp), %r15
leaq 0x10(%rsp), %rsi
movw $0x0, 0x4(%rsi)
movl $0x0, (%rsi)
leaq 0xe(%rsp), %rcx
movl $0x6, %edx
movq %r15, %rdi
callq 0x2093a
leaq 0x58(%rsp), %r15
leaq 0xa8(%rsp), %rsi
movw $0x0, 0x4(%rsi)
movl $0x0, (%rsi)
leaq 0xd(%rsp), %rcx
movl $0x6, %edx
movq %r15, %rdi
callq 0x2093a
leaq 0x70(%rsp), %r15
leaq 0xa0(%rsp), %rsi
movw $0x0, 0x4(%rsi)
movl $0x0, (%rsi)
leaq 0xc(%rsp), %rcx
movl $0x6, %edx
movq %r15, %rdi
callq 0x2093a
leaq 0x88(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0xb(%rsp), %rcx
movl $0x4, %edx
callq 0x2097e
movl $0x60, %r14d
movq 0x10(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x217ee
movq 0x20(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
jne 0x217d7
movq 0x10(%rbx), %rsi
leaq 0x28(%rsp), %rdi
callq 0x20f12
leaq 0x27ce2(%rip), %rsi     # 0x494eb
leaq 0x27ce2(%rip), %rdx     # 0x494f2
leaq 0x18(%rsp), %rdi
leaq 0x88(%rsp), %rcx
leaq 0x28(%rsp), %r8
callq 0x211e7
leaq 0x28(%rsp), %rdi
callq 0x209f0
cmpb $0x0, 0x18(%rsp)
jne 0x218b2
leaq 0x28(%rsp), %rdi
callq 0x29d3a
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x21851
movq (%rax), %r8
jmp 0x21858
leaq 0x2a642(%rip), %r8      # 0x4be9a
leaq 0x27b62(%rip), %rdx     # 0x493c1
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x23, %ecx
callq 0x27a58
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x27af4
leaq 0x10(%rsp), %rdi
callq 0x27ac4
cmpq $0x0, 0x28(%rsp)
je 0x218b2
movl $0x1, %edi
callq 0x27a55
testb %al, %al
je 0x218b2
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x218b2
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x20ebe
leaq 0x88(%rsp), %rdi
callq 0x209f0
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x21907
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x27ac4
jmp 0x218ec
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x209c8
jmp 0x218fb
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x209da
jmp 0x21921
movq %rax, %rdi
callq 0x2092b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x209f0
jmp 0x21921
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x209f0
jmp 0x21982
movq %rax, %rbx
movl $0x60, %r14d
movq 0x10(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x21950
movq 0x20(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
jne 0x21939
jmp 0x21982
jmp 0x2195c
jmp 0x2195c
movq %rax, %rbx
movq -0x18(%r15), %rdi
testq %rdi, %rdi
je 0x21974
movq -0x8(%r15), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r15
cmpq %r14, %r15
jne 0x2195f
jmp 0x21982
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O3/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 0x270a6
leaq 0x28(%rsp), %rsi
movb $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movl $0x1, %edx
callq 0x2093a
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x7(%rsp), %rcx
movl $0x1, %edx
callq 0x2097e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x22857
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1d460
movq 0x20(%rbx), %rsi
leaq 0x10(%rsp), %rdi
callq 0x20f12
leaq 0x26c7f(%rip), %rsi     # 0x494eb
leaq 0x26c9c(%rip), %rdx     # 0x4950f
leaq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x211e7
leaq 0x10(%rsp), %rdi
callq 0x209f0
cmpb $0x0, 0x28(%rsp)
jne 0x22912
leaq 0x10(%rsp), %rdi
callq 0x29d3a
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x228b1
movq (%rax), %r8
jmp 0x228b8
leaq 0x295e2(%rip), %r8      # 0x4be9a
leaq 0x26b02(%rip), %rdx     # 0x493c1
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x68, %ecx
callq 0x27a58
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x27af4
leaq 0x8(%rsp), %rdi
callq 0x27ac4
cmpq $0x0, 0x10(%rsp)
je 0x22912
movl $0x1, %edi
callq 0x27a55
testb %al, %al
je 0x22912
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x22912
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x20ebe
leaq 0x38(%rsp), %rdi
callq 0x209f0
addq $0x50, %rsp
popq %rbx
retq
jmp 0x2295d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x27ac4
jmp 0x22942
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x209c8
jmp 0x22951
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x209da
jmp 0x22977
movq %rax, %rdi
callq 0x2092b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x209f0
jmp 0x22977
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x209f0
jmp 0x229a2
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x229a2
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1d460
jmp 0x229a2
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O3/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
movw $0x0, (%rsi)
movb $0x0, 0x2(%rsi)
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x3, %edx
callq 0x2093a
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movw $0x0, (%rsi)
movb $0x0, 0x2(%rsi)
leaq 0x6(%rsp), %rcx
movl $0x3, %edx
callq 0x2093a
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x5(%rsp), %rcx
movl $0x2, %edx
callq 0x2097e
movl $0x30, %r14d
movq 0x8(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x23ff4
movq 0x18(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
jne 0x23fdd
movq 0x10(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x20f12
leaq 0x254f3(%rip), %rsi     # 0x49502
leaq 0x254dc(%rip), %rdx     # 0x494f2
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rcx
leaq 0x20(%rsp), %r8
callq 0x211e7
leaq 0x20(%rsp), %rdi
callq 0x209f0
cmpb $0x0, 0x10(%rsp)
jne 0x240b5
leaq 0x20(%rsp), %rdi
callq 0x29d3a
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x24054
movq (%rax), %r8
jmp 0x2405b
leaq 0x27e3f(%rip), %r8      # 0x4be9a
leaq 0x25b95(%rip), %rdx     # 0x49bf7
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x18, %ecx
callq 0x27a58
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x27af4
leaq 0x8(%rsp), %rdi
callq 0x27ac4
cmpq $0x0, 0x20(%rsp)
je 0x240b5
movl $0x1, %edi
callq 0x27a55
testb %al, %al
je 0x240b5
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x240b5
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x20ebe
leaq 0x50(%rsp), %rdi
callq 0x209f0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x24102
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x27ac4
jmp 0x240e7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x209c8
jmp 0x240f6
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x209da
jmp 0x2411c
movq %rax, %rdi
callq 0x2092b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x209f0
jmp 0x2411c
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x209f0
jmp 0x2416f
movq %rax, %rbx
movl $0x30, %r14d
movq 0x8(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x24148
movq 0x18(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
jne 0x24131
jmp 0x2416f
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2416f
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x1d460
jmp 0x2416f
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1d900
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
xorl %esi, %esi
movl $0x1, %edx
movl $0x2, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x26e50
leaq 0x10(%rsp), %rsi
movw $0x100, (%rsi)          # imm = 0x100
movb $0x0, 0x2(%rsi)
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x3, %edx
callq 0x2093a
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movw $0x100, (%rsi)          # imm = 0x100
movb $0x0, 0x2(%rsi)
leaq 0x6(%rsp), %rcx
movl $0x3, %edx
callq 0x2093a
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x5(%rsp), %rcx
movl $0x2, %edx
callq 0x2097e
movl $0x30, %r14d
movq 0x8(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x24285
movq 0x18(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
jne 0x2426e
movq 0x10(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x20f12
leaq 0x25262(%rip), %rsi     # 0x49502
leaq 0x2524b(%rip), %rdx     # 0x494f2
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rcx
leaq 0x20(%rsp), %r8
callq 0x211e7
leaq 0x20(%rsp), %rdi
callq 0x209f0
cmpb $0x0, 0x10(%rsp)
jne 0x24346
leaq 0x20(%rsp), %rdi
callq 0x29d3a
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x242e5
movq (%rax), %r8
jmp 0x242ec
leaq 0x27bae(%rip), %r8      # 0x4be9a
leaq 0x25904(%rip), %rdx     # 0x49bf7
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x24, %ecx
callq 0x27a58
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x27af4
leaq 0x8(%rsp), %rdi
callq 0x27ac4
cmpq $0x0, 0x20(%rsp)
je 0x24346
movl $0x1, %edi
callq 0x27a55
testb %al, %al
je 0x24346
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x24346
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x20ebe
leaq 0x50(%rsp), %rdi
callq 0x209f0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x24393
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x27ac4
jmp 0x24378
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x209c8
jmp 0x24387
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x209da
jmp 0x243ad
movq %rax, %rdi
callq 0x2092b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x209f0
jmp 0x243ad
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x209f0
jmp 0x24400
movq %rax, %rbx
movl $0x30, %r14d
movq 0x8(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x243d9
movq 0x18(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
jne 0x243c2
jmp 0x24400
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x24400
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x1d460
jmp 0x24400
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O3/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
xorl %esi, %esi
xorl %edx, %edx
movl $0x2, %ecx
movl $0x3, %r8d
movl $0x1, %r9d
callq 0x26e50
leaq 0x10(%rsp), %rsi
movw $0x101, (%rsi)          # imm = 0x101
movb $0x1, 0x2(%rsi)
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x3, %edx
callq 0x2093a
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movw $0x101, (%rsi)          # imm = 0x101
movb $0x1, 0x2(%rsi)
leaq 0x6(%rsp), %rcx
movl $0x3, %edx
callq 0x2093a
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x5(%rsp), %rcx
movl $0x2, %edx
callq 0x2097e
movl $0x30, %r14d
movq 0x8(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x24512
movq 0x18(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
jne 0x244fb
movq 0x10(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x20f12
leaq 0x24fd5(%rip), %rsi     # 0x49502
leaq 0x24fbe(%rip), %rdx     # 0x494f2
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rcx
leaq 0x20(%rsp), %r8
callq 0x211e7
leaq 0x20(%rsp), %rdi
callq 0x209f0
cmpb $0x0, 0x10(%rsp)
jne 0x245d3
leaq 0x20(%rsp), %rdi
callq 0x29d3a
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x24572
movq (%rax), %r8
jmp 0x24579
leaq 0x27921(%rip), %r8      # 0x4be9a
leaq 0x25677(%rip), %rdx     # 0x49bf7
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x30, %ecx
callq 0x27a58
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x27af4
leaq 0x8(%rsp), %rdi
callq 0x27ac4
cmpq $0x0, 0x20(%rsp)
je 0x245d3
movl $0x1, %edi
callq 0x27a55
testb %al, %al
je 0x245d3
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x245d3
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x20ebe
leaq 0x50(%rsp), %rdi
callq 0x209f0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x24620
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x27ac4
jmp 0x24605
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x209c8
jmp 0x24614
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x209da
jmp 0x2463a
movq %rax, %rdi
callq 0x2092b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x209f0
jmp 0x2463a
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x209f0
jmp 0x2468d
movq %rax, %rbx
movl $0x30, %r14d
movq 0x8(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x24666
movq 0x18(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
jne 0x2464f
jmp 0x2468d
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2468d
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x1d460
jmp 0x2468d
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1d900
nop
// File: /workspace/github_cpp_makefile_star2_O3/interimadd[P]M5Stack-PixelArt/test/lcd_mock_test.cpp
// Function: (anonymous namespace)::TestLCDMock_FillRectBlackOverSize_Test::TestBody()
TEST_F(TestLCDMock, FillRectBlackOverSize)
  {
    int v_pos = 0, h_pos = 0;
    int v_len = 100, h_len = 100;
    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
xorl %esi, %esi
xorl %edx, %edx
movl $0x64, %ecx
movl $0x64, %r8d
movl $0x1, %r9d
callq 0x26e50
leaq 0x10(%rsp), %rsi
movw $0x101, (%rsi)          # imm = 0x101
movb $0x1, 0x2(%rsi)
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x3, %edx
callq 0x2093a
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movw $0x101, (%rsi)          # imm = 0x101
movb $0x1, 0x2(%rsi)
leaq 0x6(%rsp), %rcx
movl $0x3, %edx
callq 0x2093a
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x5(%rsp), %rcx
movl $0x2, %edx
callq 0x2097e
movl $0x30, %r14d
movq 0x8(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x247a0
movq 0x18(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
jne 0x24789
movq 0x10(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x20f12
leaq 0x24d47(%rip), %rsi     # 0x49502
leaq 0x24d30(%rip), %rdx     # 0x494f2
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rcx
leaq 0x20(%rsp), %r8
callq 0x211e7
leaq 0x20(%rsp), %rdi
callq 0x209f0
cmpb $0x0, 0x10(%rsp)
jne 0x24861
leaq 0x20(%rsp), %rdi
callq 0x29d3a
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x24800
movq (%rax), %r8
jmp 0x24807
leaq 0x27693(%rip), %r8      # 0x4be9a
leaq 0x253e9(%rip), %rdx     # 0x49bf7
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x3c, %ecx
callq 0x27a58
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x27af4
leaq 0x8(%rsp), %rdi
callq 0x27ac4
cmpq $0x0, 0x20(%rsp)
je 0x24861
movl $0x1, %edi
callq 0x27a55
testb %al, %al
je 0x24861
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x24861
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x20ebe
leaq 0x50(%rsp), %rdi
callq 0x209f0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x248ae
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x27ac4
jmp 0x24893
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x209c8
jmp 0x248a2
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x209da
jmp 0x248c8
movq %rax, %rdi
callq 0x2092b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x209f0
jmp 0x248c8
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x209f0
jmp 0x2491b
movq %rax, %rbx
movl $0x30, %r14d
movq 0x8(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x248f4
movq 0x18(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
jne 0x248dd
jmp 0x2491b
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2491b
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x1d460
jmp 0x2491b
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1d900
nop