LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/examples/query_interface_2/main.cpp
// Function: main
int main()
{
  try
  {
    auto Obj = Boss::Base<MyNs::Impl::Face_1_2>::Create();
    FuncForIFace1(Boss::RefObjQIPtr<MyNs::IFaces::IFace1>(Obj).Get());
    FuncForIFace2(Boss::RefObjQIPtr<MyNs::IFaces::IFace2>(Obj).Get());
  }
  catch (std::exception const &e)
  {
    std::cerr << "Error: " << e.what() << std::endl;
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rsp), %rdi
callq 0x162c8
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1617b
movq (%rdi), %rax
leaq 0x8(%rsp), %rdx
movl $0xaec344bf, %esi       # imm = 0xAEC344BF
callq *0x28(%rax)
movq 0x8(%rsp), %rdi
callq 0x16073
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x16195
movq (%rdi), %rax
callq *0x18(%rax)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x161b8
movq (%rdi), %rax
leaq 0x8(%rsp), %rdx
movl $0x37ca1505, %esi       # imm = 0x37CA1505
callq *0x28(%rax)
movq 0x8(%rsp), %rdi
callq 0x160dd
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x161d2
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x161e2
movq (%rdi), %rax
callq *0x20(%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x161f2
jmp 0x161f2
jmp 0x161fa
movq %rax, %rdi
callq 0x16358
movq %rdx, %r14
movq %rax, %rbx
jmp 0x1623b
movq %rdx, %r14
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x16232
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x16232
jmp 0x161f2
movq %rdx, %r14
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x16232
movq (%rdi), %rax
callq *0x18(%rax)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1624b
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x10(%rsp)
jmp 0x16260
jmp 0x161f2
jmp 0x161f2
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x162bb
movq %rbx, %rdi
callq 0x16930
movq %rax, %rbx
leaq 0xdf068(%rip), %rdi     # 0xf52e0
leaq 0xa3dce(%rip), %rsi     # 0xba04d
movl $0x7, %edx
callq 0x803d0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0xdf047(%rip), %rdi     # 0xf52e0
movq %rax, %rsi
callq 0x80900
movq %rax, %rdi
callq 0x801e0
callq 0x169a0
jmp 0x161e2
movq %rax, %rbx
callq 0x169a0
movq %rbx, %rdi
callq 0xb72b0
jmp 0x161f2
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk-extras/exprtk_rtc_overhead.cpp
// Function: main
int main(int argc, char* argv[])
{
   const std::size_t rounds = ((argc == 2) ? atoi(argv[1]) : 5);

   for (std::size_t i = 0; i < rounds; ++i)
   {
      vector_rtc_overhead_analysis_01<double>();
   }

   printf("-------------------------\n");

   for (std::size_t i = 0; i < rounds; ++i)
   {
      vector_rtc_overhead_analysis_02<double>();
   }

   return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x5, %ebx
cmpl $0x2, %edi
jne 0x1192c6
movq 0x8(%rsi), %rdi
callq 0x116170
movslq %eax, %rbx
testq %rbx, %rbx
je 0x1192d8
movq %rbx, %r14
callq 0x1193a5
decq %r14
jne 0x1192ce
leaq 0x1b5b97(%rip), %rdi    # 0x2cee76
callq 0x116500
testq %rbx, %rbx
je 0x1192f3
callq 0x11991e
decq %rbx
jne 0x1192e9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH11_AssociativeContainers/examples/pair.cc
// Function: preliminaries(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void preliminaries(vector<string>& v)
{
	// process v
	istream_iterator<string> input(cin), eof;
	copy(input, eof, back_inserter(v));
	sort(v.begin(), v.end(),
		 [](const string& a, const string& b)
		 { return a.size() < b.size(); });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
movq 0x3b18(%rip), %rsi      # 0x5fe0
leaq -0xe0(%rbp), %r14
movq %r14, %rdi
callq 0x3334
xorl %eax, %eax
leaq -0x38(%rbp), %r12
movq %rax, -0x18(%r12)
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
movb %al, 0x10(%r12)
movq (%r14), %rax
movq 0x8(%r14), %rsi
leaq -0x78(%rbp), %rdi
movq %rax, -0x8(%rdi)
leaq -0x68(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x10(%r14), %rdx
addq %rsi, %rdx
callq 0x36cc
movb -0xb8(%rbp), %al
movb %al, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
movq %rax, -0x8(%rdi)
leaq -0x98(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x40(%rbp), %rdx
addq %rsi, %rdx
callq 0x36cc
movb -0x28(%rbp), %al
leaq -0xb0(%rbp), %rsi
movb %al, 0x28(%rsi)
leaq -0x80(%rbp), %rdi
movq %rbx, %rdx
callq 0x338b
movq -0xa8(%rbp), %rdi
cmpq %r14, %rdi
je 0x257f
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x2120
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x2594
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x2120
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
cmpq %rbx, %r14
je 0x25fe
movq %rbx, %r15
subq %r14, %r15
movq %r15, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2acf
cmpq $0x201, %r15            # imm = 0x201
jl 0x25f3
leaq 0x200(%r14), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2f8e
cmpq %rbx, %r15
je 0x25fe
movq %r15, %rdi
callq 0x308f
addq $0x20, %r15
jmp 0x25e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2f8e
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x2613
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2120
leaq -0xc8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2632
movq -0xc8(%rbp), %rsi
incq %rsi
callq 0x2120
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0xa8(%rbp), %rdi
cmpq %r14, %rdi
je 0x2665
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x2120
jmp 0x2665
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x267f
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x2120
jmp 0x267f
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x2694
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2120
leaq -0xc8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26b3
movq -0xc8(%rbp), %rsi
incq %rsi
callq 0x2120
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH11_AssociativeContainers/examples/pair.cc
// Function: process(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
pair<string, int> process(vector<string>& v)
{
	if (!v.empty())
		return {v.back(), v.back().size()}; // list initialize
	else
		return pair<string, int>(); // explicitly constructed return value
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
cmpq %rax, (%rsi)
je 0x26ef
movq -0x18(%rax), %r14
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq -0x20(%rax), %rsi
leaq (%rsi,%r14), %rdx
movq %rbx, %rdi
callq 0x36cc
movl %r14d, 0x20(%rbx)
jmp 0x2709
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movl $0x0, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH11_AssociativeContainers/examples/pair.cc
// Function: process2(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
pair<string, int> process2(vector<string>& v)
{
	// process v
	if (!v.empty())
		return make_pair(v.back(), v.back().size());
	else
		return pair<string, int>();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rax
cmpq %rax, (%rsi)
je 0x276d
movq -0x18(%rax), %r15
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq -0x20(%rax), %rsi
leaq (%rsi,%r15), %rdx
leaq -0x48(%rbp), %r14
movq %r14, %rdi
callq 0x36cc
movq %r15, 0x20(%r14)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rcx
cmpq %r12, %rcx
je 0x2789
movq %rcx, (%rbx)
movq -0x38(%rbp), %rax
movq %rax, 0x10(%rbx)
jmp 0x2791
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movl $0x0, 0x20(%rbx)
jmp 0x27ad
movups (%r12), %xmm0
movups %xmm0, (%rax)
movq -0x40(%rbp), %rax
movq %rax, 0x8(%rbx)
movq %r12, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movl %r15d, 0x20(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH11_AssociativeContainers/examples/pair.cc
// Function: process3(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
pair<string, int> process3(vector<string>& v)
{
	// process v
	if (!v.empty())
		return pair<string, int>(v.back(), v.back().size());
	else
		return pair<string, int>();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rax
cmpq %rax, (%rsi)
je 0x27f1
movq -0x18(%rax), %r14
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq -0x20(%rax), %rsi
leaq (%rsi,%r14), %rdx
movq %rbx, %rdi
callq 0x36cc
movl %r14d, 0x20(%rbx)
jmp 0x280b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movl $0x0, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/legendddhgf[P]Text2RPG/common.cpp
// Function: stringTrim(char*, char const*, char*)
void stringTrim (char *s, const char *trim, char *ret) {
  size_t i = 0;
  // first pass skips front
  while (i < strlen(s)) { // sufficient condition because srlen decreases
    if (strchr(trim, s[i]) == nullptr) {
      break; // if beginning doesn't need to be trimmed anymore
    }
    i++;
  }
  // second pass puts the rest of s in ret
  strncpy(ret, s + i, strlen(s + i) + 1); //copy the null character too

  // third pass trims back of ret
  for (int i = strlen(ret) - 1; i >= 0; i--) {
    if (strchr(trim, ret[i]) == nullptr) {
      ret[i + 1] = '\0'; // trim everything after this character
      break;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x20c0
testq %rax, %rax
je 0x27d2
movq %rax, %r12
xorl %r13d, %r13d
movsbl (%r15,%r13), %esi
movq %r14, %rdi
callq 0x2090
testq %rax, %rax
je 0x27d5
incq %r13
cmpq %r13, %r12
jne 0x27b3
movq %r12, %r13
jmp 0x27d5
xorl %r13d, %r13d
addq %r13, %r15
movq %r15, %rdi
callq 0x20c0
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20d0
movq %rbx, %rdi
callq 0x20c0
movl %eax, %r15d
incq %r15
leaq -0x2(%r15), %rax
testl %eax, %eax
js 0x2825
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movsbl (%rbx,%rax), %esi
movq %r14, %rdi
callq 0x2090
decq %r15
testq %rax, %rax
jne 0x27fd
movl %r15d, %eax
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/legendddhgf[P]Text2RPG/common.cpp
// Function: stringToParams(char*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*, char const*)
void stringToParams(char *str, vector<string> *params, const char *delimiters) {
  string temp = string("");
  for (size_t i = 0; i < strlen(str); i++) {
    if (strchr(delimiters, str[i]) != nullptr && temp.size() > 0) {
      params->push_back(temp);
      temp = string("");
      continue;
    } else if (strchr(delimiters, str[i]) != nullptr) continue;
    temp.append(1, str[i]); // unfortunately unintuitive way of appending chars
  }
  if (temp.size() > 0) {
    params->push_back(temp);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, -0x50(%rbp)
movq %rdi, %r15
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x59e9(%rip), %rdx      # 0x8247
leaq -0x48(%rbp), %rdi
movq %rdx, %rsi
callq 0x29ba
cmpb $0x0, (%r15)
je 0x2909
xorl %ebx, %ebx
movsbl (%r15,%rbx), %r13d
movq %r14, %rdi
movl %r13d, %esi
callq 0x2090
testq %rax, %rax
je 0x28d9
cmpq $0x0, -0x40(%rbp)
je 0x28d9
movq -0x50(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2960
leaq -0x60(%rbp), %r13
movq %r13, -0x70(%rbp)
leaq -0x70(%rbp), %r12
movq %r12, %rdi
leaq 0x5992(%rip), %rdx      # 0x8247
movq %rdx, %rsi
callq 0x29ba
leaq -0x48(%rbp), %rdi
movq %r12, %rsi
callq 0x2200
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x28f5
callq 0x2160
jmp 0x28f5
testq %rax, %rax
jne 0x28f5
movq -0x40(%rbp), %rsi
movl $0x1, %ecx
leaq -0x48(%rbp), %rdi
xorl %edx, %edx
movl %r13d, %r8d
callq 0x22b0
incq %rbx
movq %r15, %rdi
callq 0x20c0
cmpq %rax, %rbx
jb 0x2876
cmpq $0x0, -0x40(%rbp)
je 0x291d
leaq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x2960
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x292f
callq 0x2160
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2942
jmp 0x2942
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2957
callq 0x2160
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O1/legendddhgf[P]Text2RPG/ArgParser.cpp
// Function: ArgParser::usage1(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ArgParser::usage1(string unexpected) {
  fprintf(stderr, "%s: unexpected field\n", unexpected.c_str());
  fprintf(stderr, "Expected Fields:\n");
  for (string s : expected) {
    fprintf(stderr, "\t%s\n", s.c_str());
  }
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x91ff(%rip), %r14      # 0xbfe0
movq (%r14), %rdi
movq (%rsi), %rdx
leaq 0x528a(%rip), %rsi      # 0x8078
xorl %eax, %eax
callq 0x2220
movq (%r14), %rcx
leaq 0x528f(%rip), %rdi      # 0x808e
movl $0x11, %esi
movl $0x1, %edx
callq 0x22c0
movq 0x50(%rbx), %r12
movq 0x58(%rbx), %r13
cmpq %r13, %r12
je 0x2e71
leaq -0x38(%rbp), %r15
leaq -0x48(%rbp), %rbx
leaq 0x5276(%rip), %r14      # 0x80a0
movq %r15, -0x48(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2c30
movq 0x9197(%rip), %rax      # 0xbfe0
movq (%rax), %rdi
movq -0x48(%rbp), %rdx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2220
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x2e68
callq 0x2160
addq $0x20, %r12
cmpq %r13, %r12
jne 0x2e2a
movl $0x1, %edi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/legendddhgf[P]Text2RPG/ArgParser.cpp
// Function: ArgParser::usage2(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ArgParser::usage2(string expectedstr) {
  fprintf(stderr, "%s: expected field but not found\n", expectedstr.c_str());
  fprintf(stderr, "Expected Fields:\n");
  for (string s : expected) {
    fprintf(stderr, "\t%s\n", s.c_str());
  }
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x9149(%rip), %r14      # 0xbfe0
movq (%r14), %rdi
movq (%rsi), %rdx
leaq 0x5201(%rip), %rsi      # 0x80a5
xorl %eax, %eax
callq 0x2220
movq (%r14), %rcx
leaq 0x51d9(%rip), %rdi      # 0x808e
movl $0x11, %esi
movl $0x1, %edx
callq 0x22c0
movq 0x50(%rbx), %r12
movq 0x58(%rbx), %r13
cmpq %r13, %r12
je 0x2f27
leaq -0x38(%rbp), %r15
leaq -0x48(%rbp), %rbx
leaq 0x51c0(%rip), %r14      # 0x80a0
movq %r15, -0x48(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2c30
movq 0x90e1(%rip), %rax      # 0xbfe0
movq (%rax), %rdi
movq -0x48(%rbp), %rdx
movq %r14, %rsi
xorl %eax, %eax
callq 0x2220
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x2f1e
callq 0x2160
addq $0x20, %r12
cmpq %r13, %r12
jne 0x2ee0
movl $0x1, %edi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/legendddhgf[P]Text2RPG/ArgParser.cpp
// Function: ArgParser::GetTarget(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string ArgParser::GetTarget(string field) {
  if (fields.find(field) == fields.end()) {
    fprintf(stderr, "%s: Not an existing field\n", field.c_str());
    exit(1);
  }
  return fields.at(field);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x18, %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x4492
testq %rax, %rax
je 0x334d
movq %r15, %rdi
movq %r14, %rsi
callq 0x4492
testq %rax, %rax
je 0x3355
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq 0x28(%rax), %rsi
movq 0x30(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2c30
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x22f4
leaq 0x4db7(%rip), %rdi      # 0x8113
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O1/tomfunkhouser[P]gaps/apps/sfl2pts/sfl2pts.cpp
// Function: ComparePlyPoints(void const*, void const*)
static int
ComparePlyPoints(const void *data1, const void *data2)
{
  // Sort by confidence
  PlyPoint *point1 = *((PlyPoint **) data1);
  PlyPoint *point2 = *((PlyPoint **) data2);
  unsigned char c1 = point1->confidence;
  unsigned char c2 = point2->confidence;
  if (c1 > c2) return -1;
  else if (c2 > c1) return 1;
  else return 0;
}

// Assembly:
movq (%rdi), %rax
cvttss2si 0x1c(%rax), %eax
movq (%rsi), %rcx
cvttss2si 0x1c(%rcx), %ecx
xorl %edx, %edx
cmpb %al, %cl
seta %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovael %edx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/enferex[P]fnplot/cs.cc
// Function: CS::CS(char const*)
CS::CS(const char *fname)
{
    FILE *fp;
    uint8_t *data;
    struct stat st;

    if (!(fp = fopen(fname, "r")))
      throw("Could not open cscope database file");

    // mmap the input cscope database
    fstat(fileno(fp), &st);
    data = (uint8_t *)mmap(NULL, st.st_size,
                           PROT_READ, MAP_PRIVATE, fileno(fp), 0);
    if (!data)
      throw("Error memory maping cscope database");

    // Initialize the data
    initHeader(data, st.st_size);
    initTrailer(data, st.st_size);
    initSymbols(data, st.st_size);

    // Done loading data
    munmap(data, st.st_size);
    fclose(fp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x60(%rdi), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rdi)
movq $0x0, 0x70(%rdi)
leaq 0x2a5c(%rip), %rsi      # 0x5200
movq %rax, %rdi
callq 0x2200
testq %rax, %rax
je 0x2848
movq %rax, %r14
movq %rax, %rdi
callq 0x21e0
movq %rsp, %r15
movl %eax, %edi
movq %r15, %rsi
callq 0x22d0
movq 0x30(%r15), %r15
movq %r14, %rdi
callq 0x21e0
xorl %edi, %edi
movq %r15, %rsi
movl $0x1, %edx
movl $0x2, %ecx
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x2300
testq %rax, %rax
je 0x2851
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x2896
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x29d0
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2cca
movq %r12, %rdi
movq %r15, %rsi
callq 0x2130
movq %r14, %rdi
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21a0
leaq 0x29b3(%rip), %r14      # 0x5202
jmp 0x2858
leaq 0x29ce(%rip), %r14      # 0x5226
movl $0x8, %edi
callq 0x2100
movq %r14, (%rax)
movq 0x5754(%rip), %rsi      # 0x7fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x22e0
movq %rax, %r14
movq (%r13), %rdi
testq %rdi, %rdi
je 0x288e
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/enferex[P]fnplot/cs.cc
// Function: CS::initHeader(unsigned char const*, unsigned long)
void CS::initHeader(const uint8_t *data, size_t data_len)
{
    pos_t pos = {0};
    char buf[1024], *tok;

    pos.data = data;
    pos.data_len = data_len;
    getLine(&pos, buf, sizeof(buf));

    // After the header are the symbols
    this->_hdr.syms_start = pos.off;

    // Load in the header: <cscope>
    tok = strtok(buf, " ");
    if (strncmp(tok, "cscope", strlen("cscope"))) {
        ERR("This does not appear to be a cscope database");
        return;
    }

    // Version
    this->_hdr.version = atoi(strtok(NULL, " "));

    // Directory
    this->_hdr.dir = strndup(strtok(NULL, " "), 1024);

    // Optionals: [-c] [-T] [-q <syms>]
    while ((tok = strtok(NULL, " "))) {
        if (tok[0] == '-' && strlen(tok) == 2) {
            if (tok[1] == 'c')
              this->_hdr.compression = true;
            else if (tok[1] == 'T')
              this->_hdr.prefix_match = true;
            else if (tok[1] == 'q')
              this->_hdr.inverted_index = true; // TODO
            else {
                ERR("Unrecognized header option");
                return;
            }
        }
        else {
            this->_hdr.trailer = atol(tok);
            break;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %rbx
xorl %r14d, %r14d
cmpb $0xa, (%rsi,%r14)
je 0x28b7
incq %r14
cmpq %rdx, %r14
jbe 0x28a8
leaq 0x1(%r14), %r15
cmpq %rdx, %r15
setae %al
cmpq $0x401, %r14            # imm = 0x401
setae %cl
orb %al, %cl
jne 0x28df
movq %rsp, %rdi
movq %r14, %rdx
callq 0x2170
movb $0x0, (%rsp,%r14)
movq %r15, 0x8(%rbx)
leaq 0x29d4(%rip), %rsi      # 0x52be
movq %rsp, %rdi
callq 0x22a0
leaq 0x29e2(%rip), %rsi      # 0x52db
movl $0x6, %edx
movq %rax, %rdi
callq 0x20f0
testl %eax, %eax
jne 0x29c2
leaq 0x29a9(%rip), %r14      # 0x52be
xorl %edi, %edi
movq %r14, %rsi
callq 0x22a0
movq %rax, %rdi
callq 0x2290
movl %eax, (%rbx)
xorl %edi, %edi
movq %r14, %rsi
callq 0x22a0
movl $0x400, %esi            # imm = 0x400
movq %rax, %rdi
callq 0x2070
movq %rax, 0x18(%rbx)
xorl %edi, %edi
movq %r14, %rsi
callq 0x22a0
testq %rax, %rax
je 0x29b5
movq %rax, %r15
leaq 0x2961(%rip), %r14      # 0x52be
cmpb $0x2d, (%r15)
jne 0x29a9
movq %r15, %rdi
callq 0x20e0
cmpq $0x2, %rax
jne 0x29a9
movzbl 0x1(%r15), %eax
cmpl $0x54, %eax
je 0x298b
cmpl $0x71, %eax
je 0x2991
cmpl $0x63, %eax
jne 0x29c9
movb $0x1, 0x4(%rbx)
jmp 0x2995
movb $0x1, 0x6(%rbx)
jmp 0x2995
movb $0x1, 0x5(%rbx)
xorl %edi, %edi
movq %r14, %rsi
callq 0x22a0
movq %rax, %r15
testq %rax, %rax
jne 0x295d
jmp 0x29b5
movq %r15, %rdi
callq 0x2210
movq %rax, 0x10(%rbx)
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
retq
callq 0x23c5
jmp 0x29b5
callq 0x23ef
jmp 0x29b5
// File: /workspace/github_cpp_makefile_star2_O1/enferex[P]fnplot/cs.cc
// Function: csPrintCallers(_IO_FILE*, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>>>>*, char const*, int)
void csPrintCallers(FILE *out, CSDB *db, const char *fn_name, int depth)
{
    cout << "Building callers... " << std::flush;
    fprintf(out, "digraph \"Callers to %s\" {\n", fn_name);
    printCallersRec(out, db, fn_name, depth);
    fprintf(out, "}\n");
    cout << "Done" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x49c0(%rip), %rbx      # 0x7fd0
leaq 0x1c5c(%rip), %rsi      # 0x5273
movl $0x14, %edx
movq %rbx, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x2140
leaq 0x1c55(%rip), %rsi      # 0x5288
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2260
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x36ac
leaq 0x1c4c(%rip), %rdi      # 0x52a3
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2320
leaq 0x1c36(%rip), %rsi      # 0x52a6
movl $0x4, %edx
movq %rbx, %rdi
callq 0x21f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/enferex[P]fnplot/cs.cc
// Function: printCallersRec(_IO_FILE*, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>>>>*, char const*, int)
static void printCallersRec(
    FILE       *out,
    CSDB       *db,
    const char *fn_name,
    int         depth)
{
    if (depth <= 0)
      return;

    for (auto pr: *db) {
        const char *item = pr.first.c_str();
        // Does 'item' call 'fn_name' ?
        if (isCallerOf(db, item, fn_name)) {
            fprintf(out, "    %s -> %s\n", item, fn_name);
            printCallersRec(out, db, item, depth - 1);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x38(%rsp)
movl %ecx, 0xc(%rsp)
testl %ecx, %ecx
jle 0x3828
movq 0x10(%rsp), %rax
movq 0x10(%rax), %r15
testq %r15, %r15
je 0x3828
movq %rdx, %r14
decl 0xc(%rsp)
leaq 0x8(%r15), %rsi
leaq 0x50(%rsp), %rdi
callq 0x3e80
movq 0x50(%rsp), %rsi
leaq 0x18(%rsp), %rdi
movq %rsi, 0x40(%rsp)
leaq 0xb(%rsp), %rdx
callq 0x3f0a
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3f48
movq %rax, %rbx
movq %r15, 0x48(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x3746
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21c0
movq (%rbx), %rbp
movq 0x8(%rbx), %r13
cmpq %r13, %rbp
setne %r15b
je 0x37a6
movb $0x1, %r15b
movq (%rbp), %rsi
movq (%rsi), %rax
leaq 0x18(%rsp), %rdi
callq *(%rax)
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2250
movl %eax, %r12d
leaq 0x28(%rsp), %rax
cmpq %rax, %rbx
je 0x3794
movq 0x28(%rsp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x21c0
testl %r12d, %r12d
je 0x37a6
addq $0x8, %rbp
cmpq %r13, %rbp
setne %r15b
jne 0x3759
testb $0x1, %r15b
movq 0x48(%rsp), %r15
je 0x37e6
movq 0x38(%rsp), %rbx
movq %rbx, %rdi
leaq 0x1bae(%rip), %rsi      # 0x536e
movq 0x40(%rsp), %r12
movq %r12, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2260
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
movl 0xc(%rsp), %ecx
callq 0x36ac
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x3800
movq 0x80(%rsp), %rsi
subq %rdi, %rsi
callq 0x21c0
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x381c
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x21c0
movq (%r15), %r15
testq %r15, %r15
jne 0x36ec
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x3860
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21c0
jmp 0x3860
jmp 0x385d
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3ed6
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/enferex[P]fnplot/cs.cc
// Function: csPrintCallees(_IO_FILE*, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>>>>*, char const*, int)
void csPrintCallees(FILE *out, CSDB *db, const char *fn_name, int depth)
{
    cout << "Building callees... " << std::flush;
    fprintf(out, "digraph \"Callees of %s\" {\n", fn_name);
    printCalleesRec(out, db, fn_name, depth);
    fprintf(out, "}\n");
    cout << "Done" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x4744(%rip), %rbx      # 0x7fd0
leaq 0x1a18(%rip), %rsi      # 0x52ab
movl $0x14, %edx
movq %rbx, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x2140
leaq 0x1a11(%rip), %rsi      # 0x52c0
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2260
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x3928
leaq 0x19d0(%rip), %rdi      # 0x52a3
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2320
leaq 0x19ba(%rip), %rsi      # 0x52a6
movl $0x4, %edx
movq %rbx, %rdi
callq 0x21f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/enferex[P]fnplot/cs.cc
// Function: printCalleesRec(_IO_FILE*, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<CSFuncCall const*, std::allocator<CSFuncCall const*>>>>>*, char const*, int)
static void printCalleesRec(
    FILE       *out,
    CSDB       *db,
    const char *fn_name,
    int         depth)
{
    if (depth <= 0)
      return;

    for (auto callee: (*db)[fn_name]) {
        fprintf(out, "    %s -> %s\n", fn_name, callee->getName().c_str());
        printCalleesRec(out, db, callee->getName().c_str(), depth - 1);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %ecx, 0x4(%rsp)
testl %ecx, %ecx
jle 0x3a31
movq %rdi, %r12
leaq 0x8(%rsp), %rdi
leaq 0x3(%rsp), %rdx
movq 0x30(%rsp), %rsi
callq 0x3f0a
leaq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0x3f48
movq %rax, %r13
leaq 0x18(%rsp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x3990
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
movq (%r13), %r15
movq 0x8(%r13), %rbx
cmpq %rbx, %r15
je 0x3a31
decl 0x4(%rsp)
leaq 0x8(%rsp), %r13
movq (%r15), %rbp
movq (%rbp), %rax
movq %r13, %rdi
movq %rbp, %rsi
callq *(%rax)
movq 0x8(%rsp), %rcx
movq %r12, %rdi
leaq 0x19a6(%rip), %rsi      # 0x536e
movq 0x30(%rsp), %rdx
xorl %eax, %eax
callq 0x2260
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x39eb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
movq (%rbp), %rax
movq %r13, %rdi
movq %rbp, %rsi
callq *(%rax)
movq 0x8(%rsp), %rdx
movq %r12, %rdi
movq 0x28(%rsp), %rsi
movl 0x4(%rsp), %ecx
callq 0x3928
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3a24
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
addq $0x8, %r15
cmpq %rbx, %r15
jne 0x39aa
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x3a65
jmp 0x3a72
movq %rax, %rbx
jmp 0x3a72
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3a72
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O1/wandernauta[P]ttasks/TodoList.cpp
// Function: TodoList::parse()
void TodoList::parse() {
  tasks.clear();

  std::ifstream ifs(path.c_str());

  if (!ifs.good()) {
    std::cerr << "Fatal: Can't open " << path.c_str() << "." << std::endl;
    exit(1);
  }

  while (ifs.good()) {
    std::string line = "";
    getline(ifs, line);

    if (line != "") {
      int taskno = atoi(line.c_str());
      std::string::size_type taskdesc = line.find_first_not_of("1234567890. ");
      if (taskdesc == std::string::npos) continue;
      tasks[taskno] = std::string(line, taskdesc); 
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rdi, %rbx
callq 0x3f6a
movq 0x30(%rbx), %rsi
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x2350
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x70(%rsp,%rax)
jne 0x2f13
movq 0x50(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x70(%rsp,%rax)
jne 0x2ef7
leaq 0x20(%rsp), %r13
leaq 0x1350(%rip), %r15      # 0x415b
leaq 0x10(%rsp), %r12
leaq 0x30(%rsp), %rbp
movq %r13, 0x10(%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x2bc2
movq 0x50(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2360
movq %r12, %rdi
movq %r15, %rsi
callq 0x2080
testl %eax, %eax
je 0x2ecc
movq 0x10(%rsp), %rdi
callq 0x22d0
movl %eax, 0xc(%rsp)
movl $0xc, %ecx
movq %r12, %rdi
leaq 0x12d7(%rip), %rsi      # 0x414f
xorl %edx, %edx
callq 0x2310
cmpq $-0x1, %rax
je 0x2ecc
movq %rbp, %rdi
movq %r12, %rsi
movq %rax, %rdx
leaq 0xb(%rsp), %rcx
callq 0x2200
movq %rbx, %rdi
leaq 0xc(%rsp), %rsi
callq 0x36f4
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2270
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x2ecc
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21f0
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x2ee3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21f0
movq 0x50(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x70(%rsp,%rax)
je 0x2e15
leaq 0x50(%rsp), %rdi
callq 0x2060
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x40d6(%rip), %rdi      # 0x6ff0
leaq 0x12f5(%rip), %rsi      # 0x4216
movl $0x12, %edx
callq 0x2230
movq 0x30(%rbx), %rsi
movq 0x40ba(%rip), %rdi      # 0x6ff0
callq 0x21d0
movq %rax, %rbx
leaq 0x1171(%rip), %rsi      # 0x40b6
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
movq %rbx, %rdi
callq 0x20e0
movl $0x1, %edi
callq 0x2250
jmp 0x2f89
jmp 0x2f8e
movq %rax, %rbx
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x2f91
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21f0
jmp 0x2f91
movq %rax, %rbx
jmp 0x2fa8
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x2fa8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x50(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/wandernauta[P]ttasks/TodoList.cpp
// Function: TodoList::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void TodoList::add(std::string task) {
  if (task.find_first_not_of("1234567890. ") == std::string::npos) return;

  std::cout << "Added #" << first_unset() << ": " << task << std::endl;
  tasks.insert(std::make_pair(first_unset(), task));
  write();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x117f(%rip), %rsi      # 0x414f
movl $0xc, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x2310
cmpq $-0x1, %rax
je 0x30ba
movq 0x3fe0(%rip), %r15      # 0x6fd0
leaq 0x11f8(%rip), %rsi      # 0x41ef
movl $0x7, %edx
movq %r15, %rdi
callq 0x2230
movq %rbx, %rdi
callq 0x30e6
movq %r15, %rdi
movl %eax, %esi
callq 0x2320
movq %rax, %r15
leaq 0x11d7(%rip), %rsi      # 0x41f7
movl $0x2, %edx
movq %rax, %rdi
callq 0x2230
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x2230
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
movq %rbx, %rdi
callq 0x30e6
leaq 0x10(%rsp), %rdi
movl %eax, -0x8(%rdi)
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x37e0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3b94
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x30b2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x3178
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x30de
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/wandernauta[P]ttasks/TodoList.cpp
// Function: TodoList::first_unset()
int TodoList::first_unset() {
  if (tasks.size()) {
    for (int i = 1; i < tasks.rbegin()->first; i++) {
      if (!tasks.count(i)) return i;
    }
    return tasks.rbegin()->first + 1;
  } else {
    return 1;
  }
}

// Assembly:
cmpq $0x0, 0x28(%rdi)
je 0x3171
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x2210
movl 0x20(%rax), %eax
movl $0x1, %ecx
cmpl $0x2, %eax
setge %dl
jl 0x3161
movq 0x10(%r14), %rsi
movq %rbx, %rdi
testq %rsi, %rsi
je 0x313f
movq %rsi, %r8
movq %rbx, %rdi
xorl %r9d, %r9d
cmpl %ecx, 0x20(%r8)
setl %r9b
cmovgeq %r8, %rdi
movq 0x10(%r8,%r9,8), %r8
testq %r8, %r8
jne 0x3126
movq %rbx, %r8
cmpq %rbx, %rdi
je 0x3151
cmpl 0x20(%rdi), %ecx
cmovlq %rbx, %rdi
movq %rdi, %r8
cmpq %rbx, %r8
je 0x3161
incl %ecx
cmpl %eax, %ecx
setl %dl
jne 0x3118
movl %eax, %ecx
incl %eax
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/wandernauta[P]ttasks/TodoList.cpp
// Function: TodoList::write()
void TodoList::write() {
  std::ofstream ofs(path.c_str());

  tmap::iterator it;

  for (it = tasks.begin(); it != tasks.end(); ++it) {
    ofs << get(it->first) << std::endl;
  }

  ofs.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
movq 0x30(%rdi), %rsi
leaq 0x28(%rsp), %rdi
movl $0x10, %edx
callq 0x2220
movq 0x18(%rbx), %r14
leaq 0x8(%rbx), %rbp
cmpq %rbp, %r14
je 0x3231
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
movl 0x20(%r14), %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x342a
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r12, %rdi
callq 0x2230
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3221
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x2150
movq %rax, %r14
cmpq %rbp, %rax
jne 0x31ba
leaq 0x28(%rsp), %rdi
callq 0x2290
movq 0x3d7e(%rip), %rax      # 0x6fc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x30(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x28(%rsp,%rcx)
callq 0x2190
leaq 0x120(%rsp), %rdi
callq 0x20a0
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3281
movq %rax, %rbx
jmp 0x32a5
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x32a5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x28(%rsp), %rdi
callq 0x22b0
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O1/wandernauta[P]ttasks/TodoList.cpp
// Function: TodoList::erase(int)
void TodoList::erase(int num) {
  if (tasks.count(num)) {
    std::cout << "Erased #" << num << ": " << tasks[num] << std::endl;
    tasks.erase(num);
    write();
  } else {
    std::cerr << "There is no task #" << num << "." << std::endl;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movq 0x10(%rdi), %rdx
leaq 0x8(%rdi), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x32f2
movq %rax, %rcx
xorl %edi, %edi
cmpl %esi, 0x20(%rdx)
setl %dil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x32db
movq %rax, %rdx
cmpq %rax, %rcx
je 0x3304
cmpl %esi, 0x20(%rcx)
cmovgq %rax, %rcx
movq %rcx, %rdx
cmpq %rax, %rdx
je 0x33bb
movq 0x3cbc(%rip), %r15      # 0x6fd0
leaq 0xedf(%rip), %rsi       # 0x41fa
movl $0x8, %edx
movq %r15, %rdi
callq 0x2230
leaq 0xc(%rsp), %r14
movl (%r14), %esi
movq %r15, %rdi
callq 0x2320
movq %rax, %r15
leaq 0xeb5(%rip), %rsi       # 0x41f7
movl $0x2, %edx
movq %rax, %rdi
callq 0x2230
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36f4
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x2230
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
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3e7c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3ef4
movq %rbx, %rdi
callq 0x3178
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x3c2e(%rip), %rbx      # 0x6ff0
leaq 0xe3a(%rip), %rsi       # 0x4203
movl $0x12, %edx
movq %rbx, %rdi
callq 0x2230
movl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0x2320
movq %rax, %rbx
leaq 0xcca(%rip), %rsi       # 0x40b6
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O1/wandernauta[P]ttasks/TodoList.cpp
// Function: TodoList::get[abi:cxx11](int)
std::string TodoList::get(int num) {
  std::ostringstream oss;
  oss << num;
  oss << ". ";
  oss << tasks[num];
  return oss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2280
movl 0x4(%rsp), %esi
movq %r15, %rdi
callq 0x2320
leaq 0xcf9(%rip), %rsi       # 0x4159
leaq 0x8(%rsp), %rdi
movl $0x2, %edx
callq 0x2230
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x36f4
movq (%rax), %rsi
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
callq 0x2230
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x22f0
movq 0x3b27(%rip), %rsi      # 0x6fc8
leaq 0x8(%rsp), %rdi
callq 0x2100
leaq 0x78(%rsp), %rdi
callq 0x20a0
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x3af9(%rip), %rsi      # 0x6fc8
leaq 0x8(%rsp), %rdi
callq 0x2100
leaq 0x78(%rsp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O1/wandernauta[P]ttasks/TodoList.cpp
// Function: TodoList::reorder()
void TodoList::reorder() {
  int i = 1;
  tmap tnew;
  tmap::iterator it;

  for (it = tasks.begin(); it != tasks.end(); ++it) {
    tnew[i] = it->second;
    i++;
  }

  tasks = tnew;
  write();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movl $0x1, 0xc(%rsp)
leaq 0x18(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq 0x18(%rdi), %r14
leaq 0x8(%rdi), %r13
cmpq %r13, %r14
je 0x3645
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x36f4
leaq 0x28(%r14), %rsi
movq %rax, %rdi
callq 0x2110
incl 0xc(%rsp)
movq %r14, %rdi
callq 0x2150
movq %rax, %r14
cmpq %r13, %rax
jne 0x361a
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3870
movq %rbx, %rdi
callq 0x3178
leaq 0x10(%rsp), %rdi
callq 0x29b0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3674
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x29b0
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/util.cpp
// Function: XConfigureWindowValueMaskToString[abi:cxx11](unsigned long)
std::string XConfigureWindowValueMaskToString(unsigned long value_mask)
{
    std::vector<std::string> masks;
    if (value_mask & CWX) {
        masks.emplace_back("X");
    }
    if (value_mask & CWY) {
        masks.emplace_back("Y");
    }
    if (value_mask & CWWidth) {
        masks.emplace_back("Width");
    }
    if (value_mask & CWHeight) {
        masks.emplace_back("Height");
    }
    if (value_mask & CWBorderWidth) {
        masks.emplace_back("BorderWidth");
    }
    if (value_mask & CWSibling) {
        masks.emplace_back("Sibling");
    }
    if (value_mask & CWStackMode) {
        masks.emplace_back("StackMode");
    }
    return Join(masks, "|");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
testb $0x1, %r14b
je 0x4551
leaq 0x5f42(%rip), %rsi      # 0xa48b
movq %rsp, %rdi
callq 0x4cec
testb $0x2, %r14b
je 0x4566
leaq 0x5f2f(%rip), %rsi      # 0xa48d
movq %rsp, %rdi
callq 0x4cec
testb $0x4, %r14b
je 0x457b
leaq 0x5f29(%rip), %rsi      # 0xa49c
movq %rsp, %rdi
callq 0x4d42
testb $0x8, %r14b
je 0x4590
leaq 0x5f07(%rip), %rsi      # 0xa48f
movq %rsp, %rdi
callq 0x4d98
testb $0x10, %r14b
je 0x45a5
leaq 0x5ef9(%rip), %rsi      # 0xa496
movq %rsp, %rdi
callq 0x4dee
testb $0x20, %r14b
je 0x45ba
leaq 0x5ef0(%rip), %rsi      # 0xa4a2
movq %rsp, %rdi
callq 0x4e44
testb $0x40, %r14b
je 0x45cf
leaq 0x5ee3(%rip), %rsi      # 0xa4aa
movq %rsp, %rdi
callq 0x4e9a
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x5ed5(%rip), %rsi      # 0xa4b4
leaq 0x5ecf(%rip), %rdx      # 0xa4b5
leaq 0x18(%rsp), %rdi
callq 0x6280
movq %rsp, %rsi
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x4ef0
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x4617
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3250
movq %rsp, %rdi
callq 0x4fb4
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x464b
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3250
jmp 0x464b
jmp 0x4648
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4fb4
movq %rbx, %rdi
callq 0x3430
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/./util.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Join<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
::std::string Join(const Container& container, const ::std::string& delimiter)
{
    ::std::ostringstream out;
    for (auto i = container.cbegin(); i != container.cend(); ++i) {
        if (i != container.cbegin()) {
            out << delimiter;
        }
        out << *i;
    }
    return out.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3300
movq (%r15), %r13
cmpq 0x8(%r15), %r13
je 0x4f4f
leaq 0x8(%rsp), %r12
cmpq (%r15), %r13
je 0x4f35
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0x32a0
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r12, %rdi
callq 0x32a0
addq $0x20, %r13
cmpq 0x8(%r15), %r13
jne 0x4f21
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x33c0
movq 0xa06d(%rip), %rsi      # 0xefd0
leaq 0x8(%rsp), %rdi
callq 0x3110
leaq 0x78(%rsp), %rdi
callq 0x30a0
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4f8d
movq %rax, %rbx
movq 0xa039(%rip), %rsi      # 0xefd0
leaq 0x8(%rsp), %rdi
callq 0x3110
leaq 0x78(%rsp), %rdi
callq 0x30a0
movq %rbx, %rdi
callq 0x3430
nop
// File: /workspace/github_cpp_makefile_star2_O1/nishalkulkarni[P]fluid-wm/bsp.cpp
// Function: Node::set_dimensions(int, int, int, int)
void Node::set_dimensions(int w, int h, int x, int y)
{
    this->width = w;
    this->height = h;
    this->x = x;
    this->y = y;
}

// Assembly:
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movl %r8d, 0xc(%rdi)
retq
nop