LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/saicanon.cc
// Function: SET_ORIGIN_OFFSETS(double, double, double, double, double, double, double, double, double)
void SET_ORIGIN_OFFSETS(
 double x, double y, double z
 , double a  /*AA*/
 , double b  /*BB*/
 , double c  /*CC*/
 , double u, double v, double w
)
{
  fprintf(_outfile, "%5d ", _line_number++);
  print_nc_line_number();
  fprintf(_outfile, "SET_ORIGIN_OFFSETS(%.4f, %.4f, %.4f"
         ", %.4f"  /*AA*/
         ", %.4f"  /*BB*/
         ", %.4f"  /*CC*/
         ")\n", x, y, z
         , a  /*AA*/
         , b  /*BB*/
         , c  /*CC*/
         );
  _program_position_x = _program_position_x + _program_origin_x - x;
  _program_position_y = _program_position_y + _program_origin_y - y;
  _program_position_z = _program_position_z + _program_origin_z - z;
  _program_position_a = _program_position_a + _program_origin_a - a;/*AA*/
  _program_position_b = _program_position_b + _program_origin_b - b;/*BB*/
  _program_position_c = _program_position_c + _program_origin_c - c;/*CC*/

  _program_origin_x = x;
  _program_origin_y = y;
  _program_origin_z = z;
  _program_origin_a = a;  /*AA*/
  _program_origin_b = b;  /*BB*/
  _program_origin_c = c;  /*CC*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm5, -0x30(%rbp)
movsd %xmm4, -0x28(%rbp)
movsd %xmm3, -0x20(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm0, -0x8(%rbp)
movq 0x8c70(%rip), %rdi      # 0xe2f0
movl 0x7b1e(%rip), %edx      # 0xd1a4
leal 0x1(%rdx), %eax
movl %eax, 0x7b15(%rip)      # 0xd1a4
leaq 0x3b82(%rip), %rsi      # 0x9218
xorl %eax, %eax
callq 0x4230
callq 0x54d0
movq 0x8c47(%rip), %rdi      # 0xe2f0
leaq 0x3b84(%rip), %rsi      # 0x9234
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
movsd -0x18(%rbp), %xmm2
movsd -0x20(%rbp), %xmm3
movsd -0x28(%rbp), %xmm4
movsd -0x30(%rbp), %xmm5
movb $0x6, %al
callq 0x4230
movsd 0xa513(%rip), %xmm0     # 0xfbf0
addsd 0xa513(%rip), %xmm0     # 0xfbf8
movsd -0x8(%rbp), %xmm6
subsd %xmm6, %xmm0
movsd %xmm0, 0xa4fa(%rip)     # 0xfbf0
movsd 0xa502(%rip), %xmm0     # 0xfc00
addsd 0xa502(%rip), %xmm0     # 0xfc08
movsd -0x10(%rbp), %xmm5
subsd %xmm5, %xmm0
movsd 0xa4f9(%rip), %xmm1     # 0xfc10
addsd 0xa4f9(%rip), %xmm1     # 0xfc18
movsd %xmm0, 0xa4d9(%rip)     # 0xfc00
movsd -0x18(%rbp), %xmm4
subsd %xmm4, %xmm1
movsd %xmm1, 0xa4d8(%rip)     # 0xfc10
movsd 0xa4e0(%rip), %xmm0     # 0xfc20
addsd 0xa4e0(%rip), %xmm0     # 0xfc28
movsd -0x20(%rbp), %xmm3
subsd %xmm3, %xmm0
movsd %xmm0, 0xa4c7(%rip)     # 0xfc20
movsd 0xa4cf(%rip), %xmm0     # 0xfc30
addsd 0xa4cf(%rip), %xmm0     # 0xfc38
movsd -0x28(%rbp), %xmm2
subsd %xmm2, %xmm0
movsd %xmm0, 0xa4b6(%rip)     # 0xfc30
movsd 0xa4be(%rip), %xmm0     # 0xfc40
addsd 0xa4be(%rip), %xmm0     # 0xfc48
movsd -0x30(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0xa4a5(%rip)     # 0xfc40
movsd %xmm6, 0xa455(%rip)     # 0xfbf8
movsd %xmm5, 0xa45d(%rip)     # 0xfc08
movsd %xmm4, 0xa465(%rip)     # 0xfc18
movsd %xmm3, 0xa46d(%rip)     # 0xfc28
movsd %xmm2, 0xa475(%rip)     # 0xfc38
movsd %xmm1, 0xa47d(%rip)     # 0xfc48
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/saicanon.cc
// Function: STRAIGHT_TRAVERSE(int, double, double, double, double, double, double, double, double, double)
void STRAIGHT_TRAVERSE( int line_number,
 double x, double y, double z
 , double a /*AA*/
 , double b /*BB*/
 , double c /*CC*/
 , double u, double v, double w
)
{
  fprintf(_outfile, "%5d ", _line_number++);
  print_nc_line_number();
  fprintf(_outfile, "STRAIGHT_TRAVERSE(%.4f, %.4f, %.4f"
         ", %.4f" /*AA*/
         ", %.4f" /*BB*/
         ", %.4f" /*CC*/
         ")\n", x, y, z
         , a /*AA*/
         , b /*BB*/
         , c /*CC*/
         );
  line_demo(spi_fd, 
				get_pulse_x(x-_program_position_x),
				get_pulse_y(y-_program_position_y),
				get_pulse_z(z-_program_position_z));
  
  _program_position_x = x;
  _program_position_y = y;
  _program_position_z = z;
  _program_position_a = a; /*AA*/
  _program_position_b = b; /*BB*/
  _program_position_c = c; /*CC*/
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movsd %xmm5, -0x48(%rbp)
movsd %xmm4, -0x40(%rbp)
movsd %xmm3, -0x38(%rbp)
movsd %xmm2, -0x30(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd %xmm0, -0x20(%rbp)
movq 0x87da(%rip), %rdi      # 0xe2f0
movl 0x7688(%rip), %edx      # 0xd1a4
leal 0x1(%rdx), %eax
movl %eax, 0x767f(%rip)      # 0xd1a4
leaq 0x36ec(%rip), %rsi      # 0x9218
xorl %eax, %eax
callq 0x4230
callq 0x54d0
movq 0x87b1(%rip), %rdi      # 0xe2f0
leaq 0x37a2(%rip), %rsi      # 0x92e8
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm2
movsd -0x38(%rbp), %xmm3
movsd -0x40(%rbp), %xmm4
movsd -0x48(%rbp), %xmm5
movb $0x6, %al
callq 0x4230
leaq 0x7656(%rip), %rax      # 0xd1c8
movl (%rax), %ebx
movsd -0x20(%rbp), %xmm0
subsd 0xa06f(%rip), %xmm0     # 0xfbf0
cvtsd2ss %xmm0, %xmm0
callq 0x491b
movl %eax, %r14d
movsd -0x28(%rbp), %xmm0
subsd 0xa066(%rip), %xmm0     # 0xfc00
cvtsd2ss %xmm0, %xmm0
callq 0x492d
movl %eax, %r15d
movsd -0x30(%rbp), %xmm0
subsd 0xa05d(%rip), %xmm0     # 0xfc10
cvtsd2ss %xmm0, %xmm0
callq 0x493f
movl %ebx, %edi
movl %r14d, %esi
movl %r15d, %edx
movl %eax, %ecx
callq 0x46c6
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0xa018(%rip)     # 0xfbf0
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0xa01b(%rip)     # 0xfc00
movsd -0x30(%rbp), %xmm0
movsd %xmm0, 0xa01e(%rip)     # 0xfc10
movsd -0x38(%rbp), %xmm0
movsd %xmm0, 0xa021(%rip)     # 0xfc20
movsd -0x40(%rbp), %xmm0
movsd %xmm0, 0xa024(%rip)     # 0xfc30
movsd -0x48(%rbp), %xmm0
movsd %xmm0, 0xa027(%rip)     # 0xfc40
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/saicanon.cc
// Function: NURBS_FEED(int, std::vector<CONTROL_POINT, std::allocator<CONTROL_POINT>>, unsigned int)
void NURBS_FEED(int lineno,
std::vector<CONTROL_POINT> nurbs_control_points, unsigned int k)
{
  fprintf(_outfile, "%5d ", _line_number++);
  print_nc_line_number();
  fprintf(_outfile, "NURBS_FEED(%lu, ...)\n", (unsigned long)nurbs_control_points.size());

  _program_position_x = nurbs_control_points[nurbs_control_points.size()].X;
  _program_position_y = nurbs_control_points[nurbs_control_points.size()].Y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x7f41(%rip), %rdi      # 0xe2f0
movl 0x6def(%rip), %edx      # 0xd1a4
leal 0x1(%rdx), %eax
movl %eax, 0x6de6(%rip)      # 0xd1a4
leaq 0x2e53(%rip), %rsi      # 0x9218
xorl %eax, %eax
callq 0x4230
callq 0x54d0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
movq 0x7f11(%rip), %rdi      # 0xe2f0
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
leaq 0x3117(%rip), %rsi      # 0x950f
xorl %eax, %eax
callq 0x4230
movq 0x8(%rbx), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x97e1(%rip)     # 0xfbf0
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x97e4(%rip)     # 0xfc00
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sundale[P]gcode/saicanon.cc
// Function: GET_EXTERNAL_PARAMETER_FILE_NAME(char*, int)
void GET_EXTERNAL_PARAMETER_FILE_NAME(
 char * file_name,       /* string: to copy file name into       */
 int max_size)           /* maximum number of characters to copy */
{
    // Paranoid checks
    if (0 == file_name)
	return;

    if (max_size < 0)
	return;

  if (strlen(_parameter_file_name) < (unsigned int)max_size)
    strcpy(file_name, _parameter_file_name);
  else
    file_name[0] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
sete %al
testl %esi, %esi
sets %cl
orb %al, %cl
jne 0x7ee4
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x643f(%rip), %rdi      # 0xe300
callq 0x40a0
movl %r14d, %ecx
cmpq %rcx, %rax
jae 0x7ee1
leaq 0x642b(%rip), %rsi      # 0xe300
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4150
movb $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/afborchert[P]fmt/test_suite.cpp
// Function: diff_analysis(bool, char const*, int, int, char const*, char const*)
void diff_analysis(bool implementation_defined,
      const char* format, int count1, int count2,
      const char* buf1, const char* buf2) {
   if (implementation_defined) {
      print("implementation-dependent test for \"%s\" differs:\n", format);
   } else {
      print("test for \"%s\" fails:\n", format);
   }
   if (count1 == count2) {
      print("   fmt delivers: '%s'\n", buf1);
      print("   std delivers: '%s'\n", buf2);
   } else {
      print("   fmt delivers: '%s' (%d)\n", buf1, count1);
      print("   std delivers: '%s' (%d)\n", buf2, count2);
   }
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movl %edx, %ebp
leaq 0x20(%rsp), %rdx
movq %rsi, (%rdx)
movl %ebp, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
leaq 0x3eb8b(%rip), %rax     # 0x452ec
leaq 0x3f970(%rip), %rsi     # 0x460d8
testl %edi, %edi
cmovneq %rax, %rsi
movq 0x4f85b(%rip), %rdi     # 0x55fd0
callq 0xcf36
cmpl %ebx, %ebp
jne 0x67af
movq 0x4f84b(%rip), %rbx     # 0x55fd0
leaq 0x3eb91(%rip), %rsi     # 0x4531d
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0xcf36
leaq 0x3eb94(%rip), %rsi     # 0x45334
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xcf36
jmp 0x67e8
movq 0x4f81a(%rip), %rbx     # 0x55fd0
leaq 0x3eb8e(%rip), %rsi     # 0x4534b
leaq 0x18(%rsp), %rdx
leaq 0xc(%rsp), %rcx
movq %rbx, %rdi
callq 0xe69e
leaq 0x3eb91(%rip), %rsi     # 0x45367
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0xe69e
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/afborchert[P]fmt/test_suite.cpp
// Function: diff_analysis(bool, wchar_t const*, int, int, wchar_t const*, wchar_t const*)
void diff_analysis(bool implementation_defined,
      const wchar_t* format, int count1, int count2,
      const wchar_t* buf1, const wchar_t* buf2) {
   if (implementation_defined) {
      print(L"implementation-dependent test for L\"%s\" differs:\n", format);
   } else {
      print(L"test for L\"%s\" fails:\n", format);
   }
   if (count1 == count2) {
      print(L"   fmt delivers: '%s'\n", buf1);
      print(L"   std delivers: '%s'\n", buf2);
   } else {
      print(L"   fmt delivers: '%s' (%d)\n", buf1, count1);
      print(L"   std delivers: '%s' (%d)\n", buf2, count2);
   }
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movl %edx, %ebp
leaq 0x20(%rsp), %rdx
movq %rsi, (%rdx)
movl %ebp, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
leaq 0x3f952(%rip), %rax     # 0x4616c
leaq 0x3fa13(%rip), %rsi     # 0x46234
testl %edi, %edi
cmovneq %rax, %rsi
movq 0x4f7aa(%rip), %rdi     # 0x55fd8
callq 0xeedc
cmpl %ebx, %ebp
jne 0x6868
movq 0x4f79a(%rip), %rbx     # 0x55fd8
leaq 0x3fa4b(%rip), %rsi     # 0x46290
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0xeedc
leaq 0x3fa93(%rip), %rsi     # 0x462ec
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xeedc
jmp 0x68a1
movq 0x4f769(%rip), %rbx     # 0x55fd8
leaq 0x3fad2(%rip), %rsi     # 0x46348
leaq 0x18(%rsp), %rdx
leaq 0xc(%rsp), %rcx
movq %rbx, %rdi
callq 0x1031b
leaq 0x3fb29(%rip), %rsi     # 0x463b8
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x1031b
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/afborchert[P]fmt/test_suite.cpp
// Function: check_hexfloat()
bool check_hexfloat() {
   std::ostringstream os;
   os.setf(std::ios_base::scientific | std::ios_base::fixed,
      std::ios_base::floatfield);
   os << std::numeric_limits<double>::max();
   std::string osstr(os.str());
   return osstr == "0x1.fffffffffffffp+1023";
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x6420
movq (%rbx), %rax
movq -0x18(%rax), %rax
orl $0x104, 0x38(%rsp,%rax) # imm = 0x104
movsd 0x3e48d(%rip), %xmm0    # 0x45008
movq %rbx, %rdi
callq 0x6500
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x64e0
leaq 0x3e8cd(%rip), %rsi     # 0x45464
movq %rsp, %r14
movq %r14, %rdi
callq 0x60c0
movl %eax, %ebx
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x6bbe
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6340
testl %ebx, %ebx
sete %bl
movq 0x4f3ee(%rip), %rsi     # 0x55fb8
leaq 0x20(%rsp), %rdi
callq 0x61c0
leaq 0x90(%rsp), %rdi
callq 0x6100
movl %ebx, %eax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
jmp 0x6bf0
movq %rax, %rbx
movq 0x4f3be(%rip), %rsi     # 0x55fb8
leaq 0x20(%rsp), %rdi
callq 0x61c0
leaq 0x90(%rsp), %rdi
callq 0x6100
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O3/afborchert[P]fmt/test_suite.cpp
// Function: bool check_printf<char, int, int, int>(char const*, char const*, int&&, int&&, int&&)
bool check_printf(const CharT* expected, const CharT* format,
      Values&&... values) {
   int count = sprint(nullptr, 0, format, std::forward<Values>(values)...);
   bool ok = false;
   if (count >= 0) {
      CharT* buf = new CharT[count + 1];
      sprint(buf, count + 1, format, std::forward<Values>(values)...);
      ok = compare(expected, buf) == 0;
      if (!ok) {
	 fmt::printf(
	    "std::printf deviates from standard for \"%s\": \"%.*s\"\n",
	    format, count, buf);
      }
      delete[] buf;
   } else if (!ok) {
      fmt::printf("std::printf from standard for \"%s\"\n", format);
   }
   return ok;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %r12
movq %rsi, 0x10(%rsp)
movl (%rdx), %ecx
movl (%r13), %r8d
movl (%r15), %r9d
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x64f0
movl %eax, 0xc(%rsp)
testl %eax, %eax
js 0xc580
movl %eax, %ebx
incl %ebx
movq %rbx, %rdi
callq 0x6040
movq %r12, 0x18(%rsp)
movq %rax, %r12
movq %rax, 0x20(%rsp)
movl (%rbp), %ecx
movl (%r13), %r8d
movl (%r15), %r9d
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x64f0
movq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0x6440
testl %eax, %eax
sete %bl
je 0xc576
movq 0x49a80(%rip), %rdi     # 0x55fd0
leaq 0x39ad7(%rip), %rsi     # 0x4602e
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
leaq 0x20(%rsp), %r14
movq %r14, %r8
callq 0x24616
movq (%r14), %r12
testq %r12, %r12
je 0xc59a
movq %r12, %rdi
callq 0x63f0
jmp 0xc59a
movq 0x49a49(%rip), %rdi     # 0x55fd0
leaq 0x39ad5(%rip), %rsi     # 0x46063
leaq 0x10(%rsp), %rdx
callq 0xcf36
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/afborchert[P]fmt/./printf.hpp
// Function: bool fmt::impl::parse_integer<char, long>(char const*&, long&)
bool parse_integer(const CharT*& format, T& val) {
   T v{};
   CharT ch = *format;
   constexpr T maxval = std::numeric_limits<T>::max();
   constexpr T maxval10 = maxval / 10;
   while (ch >= '0' && ch <= '9') {
      T digit = ch - '0';
      if (v > maxval10) return false;
      v *= 10;
      if (v > maxval - digit) return false;
      v += digit;
      ch = *++format;
   }
   val = v;
   return true;
}

// Assembly:
movq (%rdi), %rax
movb (%rax), %r9b
leal -0x3a(%r9), %ecx
cmpb $-0xa, %cl
jae 0xdee4
xorl %ecx, %ecx
jmp 0xdf32
incq %rax
xorl %ecx, %ecx
movabsq $0xccccccccccccccc, %rdx # imm = 0xCCCCCCCCCCCCCCC
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rdx, %rcx
jg 0xdf38
andb $0xf, %r9b
movzbl %r9b, %r9d
addq %rcx, %rcx
leaq (%rcx,%rcx,4), %rcx
movq %r9, %r10
xorq %r8, %r10
cmpq %r10, %rcx
jg 0xdf38
addq %r9, %rcx
movq %rax, (%rdi)
movb (%rax), %r9b
leal -0x3a(%r9), %r10d
incq %rax
cmpb $-0xb, %r10b
ja 0xdefd
movq %rcx, (%rsi)
movb $0x1, %al
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/afborchert[P]fmt/./printf.hpp
// Function: int fmt::snprintf<>(char*, unsigned long, char const*)
inline int snprintf(char* s, std::size_t n,
      const char* format, Values&&... values) {
   std::ostringstream os;
   int nbytes = printf(os, format, std::forward<Values>(values)...);
   if (nbytes < 0) return nbytes;
   if (n == 0) return nbytes;
   std::string result(os.str());
   if (static_cast<std::size_t>(nbytes) + 1 <= n) {
      std::strcpy(s, result.c_str());
      return nbytes;
   } else {
      std::strcpy(s, result.substr(0, n-1).c_str());
      s[n-1] = 0;
      return n-1;
   }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x340, %rsp            # imm = 0x340
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1c8(%rsp), %r15
movq %r15, %rdi
callq 0x6420
leaq 0x68(%rsp), %rdi
movq %r15, %rsi
callq 0xd3ac
testq %r13, %r13
je 0x125ba
movq %rsp, %r15
leaq 0x68(%rsp), %r12
movq %r15, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0xd5bb
cmpb $0x1, (%rsp)
jne 0x125c4
cmpw $0x0, 0x30(%rsp)
jne 0x125c4
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
subq %rsi, %rdx
movq %r12, %rdi
callq 0x6400
movq 0x18(%rsp), %r13
testq %r13, %r13
jne 0x12580
movl 0xb8(%rsp), %r15d
jmp 0x125ca
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
leaq 0x42a37(%rip), %rax     # 0x55008
leaq 0xc0(%rsp), %r12
movq %rax, -0x58(%r12)
leaq 0x42a4b(%rip), %rax     # 0x55030
movq %rax, (%r12)
movq 0x439b0(%rip), %rax     # 0x55fa0
addq $0x10, %rax
movq %rax, -0x50(%r12)
leaq 0xa8(%rsp), %rdi
callq 0x6460
movq %r12, %rdi
callq 0x6100
testq %rbx, %rbx
je 0x126b3
testl %r15d, %r15d
js 0x126b3
leaq 0x1d0(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x64e0
leal 0x1(%r15), %eax
cmpq %rbx, %rax
jbe 0x12689
decq %rbx
movq %rsp, %rdi
leaq 0x68(%rsp), %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x6370
leaq 0x10(%rsp), %r12
movq -0x10(%r12), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x62f0
cmpq %r12, %r15
je 0x1267a
movq 0x10(%rsp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x6340
movb $0x0, (%r14,%rbx)
movq 0x68(%rsp), %r12
movl %ebx, %r15d
jmp 0x12699
movq 0x68(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x62f0
leaq 0x78(%rsp), %rax
cmpq %rax, %r12
je 0x126b3
movq 0x78(%rsp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x6340
movq 0x438fe(%rip), %rsi     # 0x55fb8
leaq 0x1c8(%rsp), %rdi
callq 0x61c0
leaq 0x238(%rsp), %rdi
callq 0x6100
movl %r15d, %eax
addq $0x340, %rsp            # imm = 0x340
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1271c
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x6340
jmp 0x1271c
jmp 0x1270a
movq %rax, %rbx
jmp 0x1271c
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xdbcc
movq 0x43895(%rip), %rsi     # 0x55fb8
leaq 0x1c8(%rsp), %rdi
callq 0x61c0
leaq 0x238(%rsp), %rdi
callq 0x6100
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O3/afborchert[P]fmt/./printf.hpp
// Function: fmt::impl::uppercase_ostreambuf<char, std::char_traits<char>>::xsputn(char const*, long)
virtual std::streamsize xsputn(const char_type* s,
	    std::streamsize count) {
	 for (std::streamsize i = 0; i < count; ++i) {
	    char_type ch = s[i];
	    if (std::islower(ch, this->getloc())) {
	       ch = std::toupper(ch, this->getloc());
	    }
	    if (sbuf.sputc(ch) == traits_type::eof()) {
	       return i;
	    }
	 }
	 return count;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, 0x10(%rsp)
testq %rdx, %rdx
jle 0x13f9a
movq %rdi, %r14
leaq 0x38(%rdi), %rax
movq %rax, (%rsp)
xorl %ebx, %ebx
leaq 0x8(%rsp), %r13
movq 0x10(%rsp), %rax
movb (%rax,%rbx), %bpl
movq %r13, %rdi
movq (%rsp), %rsi
callq 0x61e0
movq %r13, %rdi
callq 0x6160
movzbl %bpl, %ecx
movq 0x30(%rax), %rax
movzwl (%rax,%rcx,2), %r15d
movq %r13, %rdi
callq 0x6460
btl $0x9, %r15d
jae 0x13f61
movq %r13, %rdi
movq (%rsp), %rsi
callq 0x61e0
movq %r13, %rdi
callq 0x6160
movq (%rax), %rcx
movsbl %bpl, %esi
movq %rax, %rdi
callq *0x10(%rcx)
movl %eax, %ebp
movq %r13, %rdi
callq 0x6460
movq 0x40(%r14), %rdi
movq 0x28(%rdi), %rax
cmpq 0x30(%rdi), %rax
jae 0x13f84
movb %bpl, (%rax)
incq 0x28(%rdi)
incq %rbx
cmpq %rbx, %r12
jne 0x13efd
jmp 0x13f95
movzbl %bpl, %esi
movq (%rdi), %rax
callq *0x68(%rax)
cmpl $-0x1, %eax
jne 0x13f76
jmp 0x13f9c
movq %r12, %rbx
jmp 0x13f9c
xorl %ebx, %ebx
cmpq %r12, %rbx
cmovlq %rbx, %r12
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13fb7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6460
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O3/afborchert[P]fmt/./printf.hpp
// Function: int fmt::snprintf<>(wchar_t*, unsigned long, wchar_t const*)
inline int snprintf(wchar_t* s, std::size_t n,
      const wchar_t* format, Values&&... values) {
   std::wostringstream os;
   int nbytes = printf(os, format, std::forward<Values>(values)...);
   if (nbytes < 0) return nbytes;
   if (n == 0) return nbytes;
   std::wstring result(os.str());
   if (static_cast<std::size_t>(nbytes) + 1 <= n) {
      std::wcscpy(s, result.c_str());
      return nbytes;
   } else {
      std::wcscpy(s, result.substr(0, n-1).c_str());
      s[n] = 0;
      return n-1;
   }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x340, %rsp            # imm = 0x340
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1c8(%rsp), %r15
movq %r15, %rdi
callq 0x6290
leaq 0x68(%rsp), %rdi
movq %r15, %rsi
callq 0xf356
testq %r13, %r13
je 0x3787c
movq %rsp, %r15
leaq 0x68(%rsp), %r12
movq %r15, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0xf4bc
cmpb $0x1, (%rsp)
jne 0x37886
cmpw $0x0, 0x30(%rsp)
jne 0x37886
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
subq %rsi, %rdx
sarq $0x2, %rdx
movq %r12, %rdi
callq 0x65c0
movq 0x18(%rsp), %r13
testq %r13, %r13
jne 0x3783e
movl 0xb8(%rsp), %r15d
jmp 0x3788c
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
leaq 0x1d9b5(%rip), %rax     # 0x55248
leaq 0xc0(%rsp), %r12
movq %rax, -0x58(%r12)
leaq 0x1d9c9(%rip), %rax     # 0x55270
movq %rax, (%r12)
movq 0x1e70e(%rip), %rax     # 0x55fc0
addq $0x10, %rax
movq %rax, -0x50(%r12)
leaq 0xa8(%rsp), %rdi
callq 0x6460
movq %r12, %rdi
callq 0x6100
testq %r14, %r14
je 0x37978
testl %r15d, %r15d
js 0x37978
leaq 0x1d0(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x60d0
leal 0x1(%r15), %eax
cmpq %r14, %rax
jbe 0x3794b
leaq -0x1(%r14), %r15
movq %rsp, %rdi
leaq 0x68(%rsp), %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x61a0
leaq 0x10(%rsp), %r12
movq -0x10(%r12), %rsi
movq %rbx, %rdi
callq 0x65d0
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x37941
movq 0x10(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6340
movl $0x0, (%rbx,%r14,4)
jmp 0x37958
movq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x65d0
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x37978
movq 0x78(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6340
movq 0x1e611(%rip), %rsi     # 0x55f90
leaq 0x1c8(%rsp), %rdi
callq 0x6110
leaq 0x238(%rsp), %rdi
callq 0x6100
movl %r15d, %eax
addq $0x340, %rsp            # imm = 0x340
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x379e6
movq 0x78(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6340
jmp 0x379e6
jmp 0x379d4
movq %rax, %rbx
jmp 0x379e6
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xfa1c
movq 0x1e5a3(%rip), %rsi     # 0x55f90
leaq 0x1c8(%rsp), %rdi
callq 0x6110
leaq 0x238(%rsp), %rdi
callq 0x6100
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O3/afborchert[P]fmt/test_suite.cpp
// Function: int sprint<wchar_t&>(wchar_t*, unsigned long, wchar_t const*, wchar_t&)
int sprint(wchar_t* buffer, std::size_t size,
      const wchar_t* format, Values&&... values) {
   if (buffer && size > 0) {
      return std::swprintf(buffer, size, format,
	 std::forward<Values>(values)...);
   } else {
      /* unfortunately the behaviour of swprintf differs
	 from that of snprintf, i.e. if size == 0, just -1
	 is returned instead of computing the required buffer
	 size */
      wchar_t buf[1024]; // should be sufficient for our tests
      return std::swprintf(buf, sizeof buf/sizeof buf[0], format,
	 std::forward<Values>(values)...);
   }
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %r8b
orb %al, %r8b
jne 0x3863d
movl (%rcx), %ecx
xorl %eax, %eax
jmp 0x64b0
subq $0x1008, %rsp           # imm = 0x1008
movl (%rcx), %ecx
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
callq 0x64b0
addq $0x1008, %rsp           # imm = 0x1008
retq
// File: /workspace/github_cpp_makefile_star2_O3/jliesch[P]ofxget/ofxhome_main.cc
// Function: main
int main() {
  try {
    string dump = OfxHomeFullDumpString();
    cout << dump << endl;
    vector<Institution> insts = OfxDumpStringToInstitutions(dump);
    //for (const auto& i : insts) {
    //  cout << i << endl;
    //}
  } catch(const string& msg) {
    cout << msg << endl;
  }

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsp, %rdi
callq 0xad14
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x156c1(%rip), %rdi     # 0x44f80
callq 0x6690
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6730
movsbl %al, %esi
movq %rbx, %rdi
callq 0x63c0
movq %rax, %rdi
callq 0x6340
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0xb3c2
leaq 0x20(%rsp), %rdi
callq 0xc680
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f918
callq 0x63b0
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x2f92c
movq %rdx, %r14
movq %rax, %rbx
jmp 0x2f945
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f945
callq 0x63b0
cmpl $0x1, %r14d
jne 0x2f97d
movq %rbx, %rdi
callq 0x6080
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq 0x1561f(%rip), %rdi     # 0x44f80
callq 0x6690
movq %rax, %rdi
callq 0x66e0
callq 0x6540
jmp 0x2f918
movq %rax, %rbx
callq 0x6540
movq %rbx, %rdi
callq 0x6430
movq %rax, %rdi
callq 0xa0b7
// File: /workspace/github_cpp_makefile_star2_O3/micahcc[P]polygon_skeleton/./simple_svg.hpp
// Function: svg::Document::save() const
bool save() const
        {
            std::ofstream ofs(file_name.c_str());
            if (!ofs.good())
                return false;

            ofs << toString();
            ofs.close();
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rdi, %rbx
movq (%rdi), %rsi
leaq -0x230(%rbp), %r14
movq %r14, %rdi
movl $0x10, %edx
callq 0x3260
movq (%r14), %rax
movq -0x18(%rax), %rax
movl -0x210(%rbp,%rax), %r14d
testl %r14d, %r14d
jne 0x3d3e
leaq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x5784
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x230(%rbp), %rdi
callq 0x3270
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d32
callq 0x3210
leaq -0x230(%rbp), %rdi
callq 0x32c0
testl %r14d, %r14d
sete %bl
movq 0x10275(%rip), %rax     # 0x13fc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x228(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x230(%rbp,%rcx)
callq 0x31f0
leaq -0x138(%rbp), %rdi
callq 0x3090
movl %ebx, %eax
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3da1
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3da4
callq 0x3210
jmp 0x3da4
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0x32e0
movq %rbx, %rdi
callq 0x3380
// File: /workspace/github_cpp_makefile_star2_O3/micahcc[P]polygon_skeleton/./simple_svg.hpp
// Function: svg::Color::toString[abi:cxx11](svg::Layout const&) const
std::string toString(Layout const &) const
        {
            std::stringstream ss;
            if (transparent)
                ss << "transparent";
            else
                ss << "rgb(" << red << "," << green << "," << blue << ")";
            return ss.str();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1a8(%rbp), %rdi
callq 0x3180
leaq -0x198(%rbp), %r15
cmpb $0x0, 0x8(%r14)
je 0x4175
movl $0xb, %r12d
leaq 0xaf00(%rip), %rsi      # 0xf073
jmp 0x41eb
leaq 0xaf03(%rip), %rsi      # 0xf07f
movl $0x4, %edx
movq %r15, %rdi
callq 0x3270
movl 0xc(%r14), %esi
movq %r15, %rdi
callq 0x3370
movq %rax, %r15
leaq 0xaee5(%rip), %rsi      # 0xf084
movl $0x1, %edx
movq %rax, %rdi
callq 0x3270
movl 0x10(%r14), %esi
movq %r15, %rdi
callq 0x3370
movq %rax, %r15
leaq 0xaec2(%rip), %rsi      # 0xf084
movl $0x1, %r12d
movl $0x1, %edx
movq %rax, %rdi
callq 0x3270
movl 0x14(%r14), %esi
movq %r15, %rdi
callq 0x3370
movq %rax, %r15
leaq 0xb7fa(%rip), %rsi      # 0xf9e5
movq %r15, %rdi
movq %r12, %rdx
callq 0x3270
leaq -0x190(%rbp), %rsi
movq %rbx, %rdi
callq 0x3310
movq 0xfd9c(%rip), %rsi      # 0x13fa8
leaq -0x1a8(%rbp), %rdi
callq 0x31a0
leaq -0x128(%rbp), %rdi
callq 0x3090
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0xfd67(%rip), %rsi      # 0x13fa8
leaq -0x1a8(%rbp), %rdi
callq 0x31a0
leaq -0x128(%rbp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x3380
nop
// File: /workspace/github_cpp_makefile_star2_O3/micahcc[P]polygon_skeleton/voronoi.cpp
// Function: points_match(std::tuple<Vector const*, Vector const*, Vector const*>, std::tuple<Vector const*, Vector const*, Vector const*>)
bool points_match(std::tuple<const Point*, const Point*, const Point*> lhs,
        std::tuple<const Point*, const Point*, const Point*> rhs)
{
    return (std::get<0>(lhs) == std::get<0>(rhs) &&
            std::get<1>(lhs) == std::get<1>(rhs) &&
            std::get<2>(lhs) == std::get<2>(rhs)) ||
           (std::get<0>(lhs) == std::get<0>(rhs) &&
            std::get<1>(lhs) == std::get<2>(rhs) &&
            std::get<2>(lhs) == std::get<1>(rhs)) ||
           (std::get<0>(lhs) == std::get<1>(rhs) &&
            std::get<1>(lhs) == std::get<2>(rhs) &&
            std::get<2>(lhs) == std::get<0>(rhs)) ||
           (std::get<0>(lhs) == std::get<1>(rhs) &&
            std::get<1>(lhs) == std::get<0>(rhs) &&
            std::get<2>(lhs) == std::get<2>(rhs)) ||
           (std::get<0>(lhs) == std::get<2>(rhs) &&
            std::get<1>(lhs) == std::get<0>(rhs) &&
            std::get<2>(lhs) == std::get<1>(rhs)) ||
           (std::get<0>(lhs) == std::get<2>(rhs) &&
            std::get<1>(lhs) == std::get<1>(rhs) &&
            std::get<2>(lhs) == std::get<0>(rhs));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rdx
movq 0x10(%rsi), %rax
cmpq %rax, %rdx
je 0x64ea
movq (%rsi), %r8
movq 0x8(%rsi), %rcx
jmp 0x650e
movq 0x8(%rdi), %r8
movq (%rsi), %r9
movq 0x8(%rsi), %rcx
cmpq %rcx, %r8
jne 0x64ff
cmpq %r9, (%rdi)
je 0x6547
cmpq %r9, %r8
je 0x6509
movq %r9, %r8
jmp 0x650e
cmpq %rcx, (%rdi)
je 0x6547
cmpq %rcx, %rdx
jne 0x652b
movq 0x8(%rdi), %rsi
cmpq %r8, %rsi
jne 0x6521
cmpq %rax, (%rdi)
je 0x6547
cmpq %rax, %rsi
jne 0x652b
cmpq %r8, (%rdi)
je 0x6547
cmpq %r8, %rdx
jne 0x6543
movq 0x8(%rdi), %rdx
cmpq %rax, %rdx
jne 0x653e
cmpq %rcx, (%rdi)
je 0x6547
cmpq %rcx, %rdx
je 0x654b
xorl %eax, %eax
jmp 0x6551
movb $0x1, %al
jmp 0x6551
cmpq %rax, (%rdi)
sete %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/micahcc[P]polygon_skeleton/voronoi.cpp
// Function: solveCircle(Vector const&, Vector const&, Vector const&)
Circle solveCircle(const Point& p, const Point& q, const Point& r)
{
    // find minimal point
    Circle circle;
    circle.center.x =
        0.5*(p.y*sqr(q.x) + p.y*sqr(q.y) - (p.y - q.y)*sqr(r.x) -
                (p.y - q.y)*sqr(r.y) - (sqr(p.x) + sqr(p.y))*q.y +
                (sqr(p.x) + sqr(p.y) - sqr(q.x) - sqr(q.y))*r.y) /
        (p.y*q.x - p.x*q.y - (p.y - q.y)*r.x + (p.x - q.x)*r.y);

    circle.center.y =
        -0.5*(p.x*sqr(q.x) + p.x*sqr(q.y) - (p.x - q.x)*sqr(r.x) -
                (p.x - q.x)*sqr(r.y) - (sqr(p.x) + sqr(p.y))*q.x +
                (sqr(p.x) + sqr(p.y) - sqr(q.x) - sqr(q.y))*r.x) /
        (p.y*q.x - p.x*q.y - (p.y - q.y)*r.x + (p.x - q.x)*r.y);

    circle.radius = sqrt(sqr(p.x - circle.center.x) + sqr(p.y - circle.center.y));
    return circle;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss (%rdi), %xmm6
movss 0x4(%rdi), %xmm9
cvtss2sd %xmm9, %xmm3
movss (%rsi), %xmm0
movss %xmm0, -0x4(%rbp)
movss 0x4(%rsi), %xmm5
cvtss2sd %xmm0, %xmm10
xorps %xmm0, %xmm0
cvtss2sd %xmm5, %xmm0
movaps %xmm0, %xmm4
mulsd %xmm0, %xmm4
movapd %xmm4, %xmm11
mulsd %xmm3, %xmm11
movapd %xmm3, %xmm7
cvtss2sd %xmm6, %xmm8
movsd %xmm8, -0x18(%rbp)
mulsd %xmm8, %xmm8
mulsd %xmm3, %xmm3
addsd %xmm8, %xmm3
mulsd %xmm3, %xmm0
movsd %xmm0, -0x10(%rbp)
movapd %xmm3, %xmm8
mulsd %xmm10, %xmm3
mulsd %xmm10, %xmm10
mulsd %xmm10, %xmm7
addsd %xmm11, %xmm7
movaps %xmm9, %xmm14
subss %xmm5, %xmm14
movss (%rdx), %xmm15
movss 0x4(%rdx), %xmm12
xorps %xmm11, %xmm11
cvtss2sd %xmm12, %xmm11
movaps %xmm11, %xmm13
subsd %xmm10, %xmm8
subsd %xmm4, %xmm8
mulsd %xmm8, %xmm11
cvtss2sd %xmm15, %xmm2
mulsd %xmm2, %xmm8
mulsd %xmm2, %xmm2
cvtss2sd %xmm14, %xmm1
movaps %xmm1, %xmm0
mulsd %xmm2, %xmm0
subsd %xmm0, %xmm7
mulsd %xmm13, %xmm13
mulsd %xmm13, %xmm1
subsd %xmm1, %xmm7
subsd -0x10(%rbp), %xmm7
addsd %xmm7, %xmm11
mulss %xmm6, %xmm5
movaps %xmm9, %xmm0
movss -0x4(%rbp), %xmm7
mulss %xmm7, %xmm0
subss %xmm5, %xmm0
mulss %xmm15, %xmm14
subss %xmm14, %xmm0
movaps %xmm6, %xmm1
subss %xmm7, %xmm1
mulss %xmm1, %xmm12
addss %xmm0, %xmm12
movsd -0x18(%rbp), %xmm0
mulsd %xmm0, %xmm4
mulsd %xmm0, %xmm10
addsd %xmm4, %xmm10
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
mulsd %xmm0, %xmm2
subsd %xmm2, %xmm10
mulsd %xmm0, %xmm13
subsd %xmm13, %xmm10
subsd %xmm3, %xmm10
addsd %xmm10, %xmm8
mulsd 0x8121(%rip), %xmm11    # 0xf240
xorps %xmm1, %xmm1
cvtss2sd %xmm12, %xmm1
divsd %xmm1, %xmm11
xorps %xmm0, %xmm0
cvtsd2ss %xmm11, %xmm0
mulsd 0x810b(%rip), %xmm8     # 0xf248
divsd %xmm1, %xmm8
xorps %xmm1, %xmm1
cvtsd2ss %xmm8, %xmm1
subss %xmm0, %xmm6
xorps %xmm2, %xmm2
cvtss2sd %xmm6, %xmm2
mulsd %xmm2, %xmm2
subss %xmm1, %xmm9
xorps %xmm3, %xmm3
cvtss2sd %xmm9, %xmm3
mulsd %xmm3, %xmm3
addsd %xmm2, %xmm3
unpcklps %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
xorps %xmm1, %xmm1
sqrtsd %xmm3, %xmm1
cvtsd2ss %xmm1, %xmm1
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/micahcc[P]polygon_skeleton/voronoi.cpp
// Function: CircleQueue::erase(Intersection const&, Intersection const&)
void erase(const Intersection& left_int, const Intersection& right_int)
    {
        CircleEvent dummy;
        const Point* ptA = left_int.pt_left;
        const Point* ptB = left_int.pt_right;
        const Point* ptC = right_int.pt_right;
        assert(ptB != nullptr);

        // no event to erase since one of the "intersections" is the null
        // intersection
        if(ptA == nullptr || ptC == nullptr)
            return;

        dummy.circle = solveCircle(*ptA, *ptB, *ptC);
        float end_y = dummy.circle.center.y - dummy.circle.radius;

        for(auto it = m_queue.lower_bound(dummy); it != m_queue.end() &&
                !(it->circle.center.y - it->circle.radius < end_y); ++it) {
            if(left_int.pt_left == it->left_int.pt_left &&
                    left_int.pt_right == it->left_int.pt_right &&
                    right_int.pt_left == it->right_int.pt_left &&
                    right_int.pt_right == it->right_int.pt_right) {
                it = m_queue.erase(it);
                break;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, -0x30(%rbp)
movq 0x8(%rsi), %r14
testq %r14, %r14
je 0xae16
movq %rdx, %r13
movq (%rsi), %r15
movq 0x8(%rdx), %r12
testq %r15, %r15
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
jne 0xaded
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x6fcc
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0xaded
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
subss %xmm1, %xmm0
movq -0x30(%rbp), %rax
leaq 0x8(%rax), %rbx
movq %rbx, %rax
movss 0x44(%rcx), %xmm1
subss 0x48(%rcx), %xmm1
xorl %edx, %edx
ucomiss %xmm1, %xmm0
cmovbeq %rcx, %rax
seta %dl
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0xad88
cmpq %rbx, %rax
je 0xaded
movq (%r13), %r13
movaps %xmm0, -0x40(%rbp)
movss 0x44(%rax), %xmm1
subss 0x48(%rax), %xmm1
ucomiss %xmm1, %xmm0
ja 0xaded
cmpq 0x20(%rax), %r15
jne 0xaddc
cmpq 0x28(%rax), %r14
jne 0xaddc
cmpq 0x30(%rax), %r13
jne 0xaddc
cmpq 0x38(%rax), %r12
je 0xadfc
movq %rax, %rdi
callq 0x3280
movaps -0x40(%rbp), %xmm0
cmpq %rbx, %rax
jne 0xadb5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb64a
leaq 0x4df0(%rip), %rdi      # 0xfc0d
leaq 0x44d6(%rip), %rsi      # 0xf2fa
leaq 0x4df1(%rip), %rcx      # 0xfc1c
movl $0x125, %edx            # imm = 0x125
callq 0x3140
nop
// File: /workspace/github_cpp_makefile_star2_O3/BrianYi[P]timer/src/main.cpp
// Function: main
int main()
{
    TimeDriver* timeDriver = new TimeDriver(1);
    AdvanceTimeWheel* advTimeWheel = new AdvanceTimeWheel;
    SecTimer* secTimer1 = new SecTimer(5);    
    SecTimer* secTimer2 = new SecTimer(10);
    SecTimer* secTimer3 = new SecTimer(60);
    MinTimer* minTimer1 = new MinTimer(1); 
    advTimeWheel->addTimer(secTimer1);
    advTimeWheel->addTimer(secTimer2);
    advTimeWheel->addTimer(secTimer3);
    advTimeWheel->addTimer(minTimer1);
    timeDriver->mountTimeWheel(advTimeWheel);
    timeDriver->start();
    delete timeDriver;
    delete advTimeWheel;
    delete secTimer1;
    delete secTimer2;
    delete secTimer3;
    delete minTimer1;
    exit(EXIT_SUCCESS);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x28, %edi
callq 0x1090
movq %rax, %rbx
movl $0x1, %esi
movq %rax, %rdi
callq 0x125c
leaq 0x487c(%rip), %rax      # 0x5cd8
movq %rax, (%rbx)
movl $0x78, %edi
callq 0x1090
movq %rax, %r14
movq %rax, %rdi
callq 0x15fa
movl $0x20, %edi
callq 0x1090
movq %rax, %r15
movq %rax, %rdi
movl $0x1388, %esi           # imm = 0x1388
movl $0x1, %edx
callq 0x1404
leaq 0x48be(%rip), %rbp      # 0x5d58
movq %rbp, (%r15)
movl $0x0, 0x18(%r15)
movl $0x20, %edi
callq 0x1090
movq %rax, %r12
movq %rax, %rdi
movl $0x2710, %esi           # imm = 0x2710
movl $0x1, %edx
callq 0x1404
movq %rbp, (%r12)
movl $0x0, 0x18(%r12)
movl $0x20, %edi
callq 0x1090
movq %rax, %r13
movq %rax, %rdi
movl $0xea60, %esi           # imm = 0xEA60
movl $0x1, %edx
callq 0x1404
movq %rbp, (%r13)
movl $0x0, 0x18(%r13)
movl $0x20, %edi
callq 0x1090
movq %rax, %rbp
leaq 0x4(%rsp), %rsi
movl $0x1, (%rsi)
movq %rax, %rdi
movl $0x1, %edx
callq 0x16a8
movq %r14, %rdi
movq %r15, %rsi
callq 0x16ca
movq %r14, %rdi
movq %r12, %rsi
callq 0x16ca
movq %r14, %rdi
movq %r13, %rsi
callq 0x16ca
movq %r14, %rdi
movq %rbp, %rsi
callq 0x16ca
movq %rbx, %rdi
movq %r14, %rsi
callq 0x127a
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq (%r12), %rax
movq %r12, %rdi
callq *0x8(%rax)
movq (%r13), %rax
movq %r13, %rdi
callq *0x8(%rax)
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x8(%rax)
xorl %edi, %edi
callq 0x10b0
movq %rbp, %rdi
movq %rax, %rbp
movl $0x20, %esi
jmp 0x15ec
movq %rax, %rbp
movl $0x20, %esi
movq %r13, %rdi
jmp 0x15ec
movq %rax, %rbp
movl $0x20, %esi
movq %r12, %rdi
jmp 0x15ec
movq %rax, %rbp
movl $0x20, %esi
movq %r15, %rdi
jmp 0x15ec
movq %rax, %rbp
movl $0x78, %esi
movq %r14, %rdi
jmp 0x15ec
movq %rax, %rbp
movl $0x28, %esi
movq %rbx, %rdi
callq 0x10a0
movq %rbp, %rdi
callq 0x1110
nop
// File: /workspace/github_cpp_makefile_star2_O3/BrianYi[P]timer/src/AdvanceTimeWheel.h
// Function: AdvanceTimeWheel::AdvanceTimeWheel()
AdvanceTimeWheel()
    {
        fMilliSec = 0;
        fSecWheelSize = 60;
        fSecFreq = 1000;
        fSecPtr = 0;
        fMinWheelSize = 60;
        fMinPtr = 0;
        fHourWheelSize = 24;
        fHourPtr = 0;
        fTotalTimerNum = 0;
        fSecWheel.resize(fSecWheelSize);
        fMinWheel.resize(fMinWheelSize);
        fHourWheel.resize(fHourWheelSize);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
leaq 0x470c(%rip), %rax      # 0x5d18
movq %rax, (%rdi)
leaq 0x30(%rdi), %rbx
leaq 0x48(%rdi), %r14
leaq 0x60(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movq $0x0, 0x70(%rdi)
movaps 0x1a33(%rip), %xmm0     # 0x3070
movups %xmm0, 0x8(%rdi)
movaps 0x1a38(%rip), %xmm0     # 0x3080
movups %xmm0, 0x18(%rdi)
xorl %eax, %eax
xchgl %eax, 0x28(%rdi)
movl $0x3c, %esi
movq %rbx, %rdi
callq 0x189c
movslq 0x18(%r12), %rsi
movq %r14, %rdi
callq 0x189c
movslq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x189c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r12
movq %r15, %rdi
callq 0x191a
movq %r14, %rdi
callq 0x191a
movq %rbx, %rdi
callq 0x191a
movq %r12, %rdi
callq 0x1110
nop
// File: /workspace/github_cpp_makefile_star2_O3/BrianYi[P]timer/src/AdvanceTimeWheel.h
// Function: AdvanceTimeWheel::addTimer(TimerInterface*)
void addTimer(TimerInterface* timer)
    {
        int timespan = timer->getTimeSpan();
        int passedSec = timespan / fSecFreq;
        ListNode *node = new ListNode;
        node->timer = timer;
        node->sec = fSecPtr + passedSec;
        node->min = fMinPtr + node->sec / fSecWheelSize;
        node->hour = fHourPtr + node->min / fMinWheelSize;
        node->sec %= fSecWheelSize;
        node->min %= fMinWheelSize;
        node->hour %= fHourWheelSize;
        if (node->hour > fHourPtr)
            fHourWheel[node->hour].push(node);
        else if (node->min > fMinPtr)
            fMinWheel[node->min].push(node);
        else if (node->sec > fSecPtr)
            fSecWheel[node->sec].push(node);
        else
            printf("error: %d:%s\r\n", __LINE__, __FUNCTION__);
        
        fTotalTimerNum++;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1422
cltd
idivl 0xc(%rbx)
movl %eax, %ebp
movl $0x18, %edi
callq 0x1090
movq %rax, %rcx
movq %rax, 0x8(%rsp)
movq %r14, (%rax)
movl 0x14(%rbx), %r8d
movl 0x1c(%rbx), %r9d
addl %r8d, %ebp
movl %ebp, %eax
cltd
idivl 0x10(%rbx)
movl %edx, %esi
addl %r9d, %eax
movl 0x24(%rbx), %r10d
cltd
idivl 0x18(%rbx)
movl %edx, %edi
addl %r10d, %eax
movl %esi, 0x10(%rcx)
movl %edx, 0xc(%rcx)
cltd
idivl 0x20(%rbx)
movl %edx, 0x8(%rcx)
cmpl %r10d, %edx
jle 0x1739
movslq %edx, %rax
movq 0x60(%rbx), %rdx
jmp 0x1753
cmpl %r9d, %edi
jle 0x1747
movslq %edi, %rax
movq 0x48(%rbx), %rdx
jmp 0x1753
cmpl %r8d, %esi
jle 0x1788
movslq %esi, %rax
movq 0x30(%rbx), %rdx
leaq (%rax,%rax,4), %rsi
shlq $0x4, %rsi
leaq (%rdx,%rsi), %rdi
movq 0x30(%rdx,%rsi), %rax
movq 0x40(%rdx,%rsi), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rax
je 0x177c
movq %rcx, (%rax)
addq $0x8, 0x30(%rdi)
jmp 0x17a2
leaq 0x8(%rsp), %rsi
callq 0x24e4
jmp 0x17a2
leaq 0x19cd(%rip), %rdi      # 0x315c
leaq 0x19d5(%rip), %rdx      # 0x316b
movl $0x5e, %esi
xorl %eax, %eax
callq 0x1030
lock
incl 0x28(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/BrianYi[P]timer/src/TimeDriver.h
// Function: TimeDriver::start()
void start()
    {
        struct timeval tv;
        gettimeofday(&tv, NULL);
        int64_t curMicrosecTMS = tv.tv_sec * 1000000 + tv.tv_usec;
        int64_t nextMicrosecTMS = curMicrosecTMS + fGranularity * 1000;
        while (true)
        {
            gettimeofday(&tv, NULL);
            curMicrosecTMS = tv.tv_sec * 1000000 + tv.tv_usec;
            if (nextMicrosecTMS - curMicrosecTMS > 0)
                usleep(nextMicrosecTMS - curMicrosecTMS);
            for (auto& timeWheelPtr : fTimeWheelArry)
                timeWheelPtr->run(fGranularity);
            nextMicrosecTMS = curMicrosecTMS + fGranularity * 1000;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x10e0
imulq $0xf4240, (%r14), %rax  # imm = 0xF4240
addq 0x8(%r14), %rax
movslq 0x20(%rbx), %rcx
imulq $0x3e8, %rcx, %r15      # imm = 0x3E8
addq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0x10e0
imulq $0xf4240, (%rsp), %r12  # imm = 0xF4240
addq 0x8(%rsp), %r12
subq %r12, %r15
jle 0x180a
movl %r15d, %edi
callq 0x10c0
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %r13
cmpq %r13, %r15
je 0x1829
movq (%r15), %rdi
movl 0x20(%rbx), %esi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x8, %r15
jmp 0x1812
movslq 0x20(%rbx), %rax
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
addq %rax, %r12
movq %r12, %r15
jmp 0x17e6
// File: /workspace/github_cpp_makefile_star2_O3/wangyu-[P]pwdgen/lib/md5.cpp
// Function: md5_update(md5_context*, unsigned char const*, unsigned long)
void md5_update( md5_context *ctx, const unsigned char *input, size_t ilen )
{
    size_t fill;
    uint32_t left;

    if( ilen == 0 )
        return;

    left = ctx->total[0] & 0x3F;
    fill = 64 - left;

    ctx->total[0] += (uint32_t) ilen;
    ctx->total[0] &= 0xFFFFFFFF;

    if( ctx->total[0] < (uint32_t) ilen )
        ctx->total[1]++;

    if( left && ilen >= fill )
    {
        memcpy( (void *) (ctx->buffer + left), input, fill );
        md5_process( ctx, ctx->buffer );
        input += fill;
        ilen  -= fill;
        left = 0;
    }

    while( ilen >= 64 )
    {
        md5_process( ctx, input );
        input += 64;
        ilen  -= 64;
    }

    if( ilen > 0 )
    {
        memcpy( (void *) (ctx->buffer + left), input, ilen );
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x403061
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %ecx
movl %ecx, %eax
andl $0x3f, %eax
movl %edx, %esi
addl %ecx, %esi
movl %esi, (%rdi)
jae 0x402fdc
incl 0x4(%r14)
testl %eax, %eax
je 0x40301a
movl $0x40, %r15d
subq %rax, %r15
movq %rdx, %r13
subq %r15, %r13
jb 0x403046
leaq 0x18(%r14), %r12
movl %eax, %eax
leaq (%r14,%rax), %rdi
addq $0x18, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x401040
movq %r14, %rdi
movq %r12, %rsi
callq 0x4027fc
addq %r15, %rbx
jmp 0x40301d
movq %rdx, %r13
cmpq $0x40, %r13
jb 0x40303c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4027fc
addq $0x40, %rbx
addq $-0x40, %r13
cmpq $0x3f, %r13
ja 0x403023
xorl %eax, %eax
movq %r13, %rdx
testq %r13, %r13
je 0x403061
movl %eax, %eax
leaq (%r14,%rax), %rdi
addq $0x18, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x401040
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/wangyu-[P]pwdgen/lib/md5.cpp
// Function: md5(unsigned char const*, unsigned long, unsigned char*)
void md5( const unsigned char *input, size_t ilen, unsigned char output[16] )
{
    /*static md5_context ctx;
    static int done=0;
    if(done==0)
    {
        md5_init( &ctx );
    	done=1;
    }*/
    md5_context ctx;
    md5_init( &ctx );
    md5_starts( &ctx );
    md5_update( &ctx, input, ilen );
    md5_finish( &ctx, output );
    md5_free( &ctx );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r12
xorl %r13d, %r13d
movl $0xd8, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x401098
movaps 0xd13fc(%rip), %xmm0    # 0x4d45a0
movups %xmm0, 0x8(%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x402fb1
movq %r12, %rdi
movq %rbx, %rsi
callq 0x40306b
movb $0x0, 0x8(%rsp,%r13)
incq %r13
cmpq $0xd8, %r13
jne 0x4031c3
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq