LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x30(%rbp)
movabsq $0xccccccccccccccc, %rax # imm = 0xCCCCCCCCCCCCCCC
movq %rax, -0x38(%rbp)
movsbl -0x21(%rbp), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x41(%rbp)
jl 0x119d7
movsbl -0x21(%rbp), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x119e0
jmp 0x11a51
movsbl -0x21(%rbp), %eax
subl $0x30, %eax
cltq
movq %rax, -0x40(%rbp)
movabsq $0xccccccccccccccc, %rax # imm = 0xCCCCCCCCCCCCCCC
cmpq %rax, -0x20(%rbp)
jle 0x11a03
movb $0x0, -0x1(%rbp)
jmp 0x11a60
imulq $0xa, -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
subq -0x40(%rbp), %rcx
cmpq %rcx, %rax
jle 0x11a29
movb $0x0, -0x1(%rbp)
jmp 0x11a60
movq -0x40(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb 0x1(%rax), %al
movb %al, -0x21(%rbp)
jmp 0x119bc
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: afborchert[P]fmt/./printf.hpp
// Function: long fmt::impl::count_digits<unsigned long>(unsigned long, long)
inline integer count_digits(Value value, integer base) {
   if (value == 0) {
      return 1;
   } else {
      integer digits = 0;
      while (value != 0) {
	 value /= base; ++digits;
      }
      return digits;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1297d
movq $0x1, -0x8(%rbp)
jmp 0x129b3
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x129ab
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x12985
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x198(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x8640
movq -0x200(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1ab60
movl %eax, -0x1f4(%rbp)
jmp 0x1a9c2
movl -0x1f4(%rbp), %eax
movl %eax, -0x19c(%rbp)
cmpl $0x0, -0x19c(%rbp)
jge 0x1aa06
movl -0x19c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x1b0(%rbp)
jmp 0x1ab2e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x1ab46
cmpq $0x0, -0x18(%rbp)
jne 0x1aa25
movl -0x19c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x1b0(%rbp)
jmp 0x1ab2e
leaq -0x1d0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x8460
jmp 0x1aa3a
movslq -0x19c(%rbp), %rax
addq $0x1, %rax
cmpq -0x18(%rbp), %rax
ja 0x1aa89
movq -0x10(%rbp), %rax
movq %rax, -0x208(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x8150
movq -0x208(%rbp), %rdi
movq %rax, %rsi
callq 0x83d0
movl -0x19c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x1b0(%rbp)
jmp 0x1ab22
movq -0x10(%rbp), %rax
movq %rax, -0x210(%rbp)
movq -0x18(%rbp), %rcx
decq %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x1f0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x8470
jmp 0x1aab4
leaq -0x1f0(%rbp), %rdi
callq 0x8150
movq -0x210(%rbp), %rdi
movq %rax, %rsi
callq 0x83d0
leaq -0x1f0(%rbp), %rdi
callq 0x8220
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
subq $0x1, %rax
movl %eax, -0x4(%rbp)
movl $0x1, -0x1b0(%rbp)
jmp 0x1ab22
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x8220
jmp 0x1ab46
leaq -0x1d0(%rbp), %rdi
callq 0x8220
leaq -0x198(%rbp), %rdi
callq 0x80c0
movl -0x4(%rbp), %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
leaq -0x198(%rbp), %rdi
callq 0x80c0
movq -0x1a8(%rbp), %rdi
callq 0x8800
nop
// File: afborchert[P]fmt/./printf.hpp
// Function: int fmt::printf<char, std::char_traits<char>>(std::basic_ostream<char, std::char_traits<char>>&, char const*)
inline int printf(std::basic_ostream<CharT, Traits>& out,
      const CharT* format) {
   impl::counting_ostream<CharT, Traits> cout(out);

   while (format) {
      auto fseg = impl::parse_format_segment(format, 0);
      if (!fseg.valid) return -1;
      if (fseg.nof_args > 0) return -1;
      cout.write(fseg.beginp, fseg.endp - fseg.beginp);
      format = fseg.nextp;
   }
   return cout.get_count();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x178(%rbp), %rdi
callq 0x10190
cmpq $0x0, -0x18(%rbp)
je 0x1ac34
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x1e0(%rbp), %rdi
callq 0x104e0
jmp 0x1aba4
testb $0x1, -0x1e0(%rbp)
jne 0x1abe6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x1f0(%rbp)
jmp 0x1ac5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e8(%rbp)
movl %eax, -0x1ec(%rbp)
leaq -0x178(%rbp), %rdi
callq 0x11180
jmp 0x1ac75
movzwl -0x1b0(%rbp), %eax
cmpl $0x0, %eax
jle 0x1ac05
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x1f0(%rbp)
jmp 0x1ac5d
movq -0x1d8(%rbp), %rsi
movq -0x1d0(%rbp), %rdx
subq %rsi, %rdx
leaq -0x178(%rbp), %rdi
callq 0x8600
jmp 0x1ac24
movq -0x1c8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x1ab83
leaq -0x178(%rbp), %rdi
callq 0x10e20
movq %rax, -0x1f8(%rbp)
jmp 0x1ac49
movq -0x1f8(%rbp), %rax
movl %eax, -0x4(%rbp)
movl $0x1, -0x1f0(%rbp)
leaq -0x178(%rbp), %rdi
callq 0x11180
movl -0x4(%rbp), %eax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1e8(%rbp), %rdi
callq 0x8800
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x1d7f5
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
movl %eax, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x8740
movl -0x6c(%rbp), %edi
movq -0x68(%rbp), %rsi
callq 0x1d8a0
movb %al, -0x59(%rbp)
jmp 0x1d73c
leaq -0x38(%rbp), %rdi
callq 0x86a0
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x1d74e
jmp 0x1d7b6
movq -0x58(%rbp), %rsi
movsbl -0x29(%rbp), %eax
movl %eax, -0x7c(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x8740
movl -0x7c(%rbp), %edi
movq -0x78(%rbp), %rsi
callq 0x1d8e0
movb %al, -0x6d(%rbp)
jmp 0x1d777
movb -0x6d(%rbp), %al
movb %al, -0x29(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x86a0
jmp 0x1d7b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x86a0
jmp 0x1d80a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x86a0
jmp 0x1d80a
movq -0x58(%rbp), %rax
movq 0x40(%rax), %rdi
movsbl -0x29(%rbp), %esi
callq 0x8140
movl %eax, -0x80(%rbp)
callq 0x113d0
movl %eax, %ecx
movl -0x80(%rbp), %eax
cmpl %ecx, %eax
jne 0x1d7e2
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1d7fd
jmp 0x1d7e4
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1d6f7
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x8800
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: afborchert[P]fmt/./printf.hpp
// Function: fmt::impl::uppercase_ostreambuf<char, std::char_traits<char>>::overflow(int)
virtual int_type overflow(int_type ch) {
	 if (ch == traits_type::eof()) {
	    return traits_type::eof();
	 } else {
	    char_type c = traits_type::to_char_type(ch);
	    return xsputn(&c, 1) == 1? ch: traits_type::eof();
	 }
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x113d0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jne 0x1d855
callq 0x113d0
movl %eax, -0x4(%rbp)
jmp 0x1d890
leaq -0x14(%rbp), %rdi
callq 0x113e0
movq -0x28(%rbp), %rdi
movb %al, -0x15(%rbp)
movq (%rdi), %rax
leaq -0x15(%rbp), %rsi
movl $0x1, %edx
callq *0x60(%rax)
cmpq $0x1, %rax
jne 0x1d882
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x1d88a
callq 0x113d0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: afborchert[P]fmt/./printf.hpp
// Function: bool fmt::impl::print_value<char, std::char_traits<char>>(std::basic_ostream<char, std::char_traits<char>>&, fmt::impl::format_segment<char> const&, std::nullptr_t)
inline bool print_value(std::basic_ostream<CharT, Traits>& out,
      const format_segment<CharT>& fseg, std::nullptr_t value) {
   if (fseg.flags & is_pointer) {
      /* %p given: print pointer value */
      out << static_cast<const void*>(value);
      return !!out;
   } else if (fseg.flags & is_unsigned) {
      /* print it as an unsigned integer value */
      print_value(out, fseg, reinterpret_cast<std::uintptr_t>(value));
      return !!out;
   } else if (fseg.flags & is_integer) {
      /* print it as a signed integer value */
      print_value(out, fseg, reinterpret_cast<std::intptr_t>(value));
      return !!out;
   } else {
      /* fail otherwise */
      return false;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x24(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x42f8d
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x82d0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x81b0
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x43015
movq -0x18(%rbp), %rax
movzwl 0x24(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x42fcf
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rdx
callq 0x120d0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x81b0
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x43015
movq -0x18(%rbp), %rax
movzwl 0x24(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x43011
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq $0x0, -0x30(%rbp)
leaq -0x30(%rbp), %rdx
callq 0x124c0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x81b0
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x43015
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: afborchert[P]fmt/./printf.hpp
// Function: std::enable_if<!is_char<int>::value, bool>::type fmt::impl::print_value<char, std::char_traits<char>, int>(std::basic_ostream<char, std::char_traits<char>>&, fmt::impl::format_segment<char> const&, int const*)
inline typename std::enable_if<!is_char<Value>::value, bool>::type
print_value(std::basic_ostream<CharT, Traits>& out,
      const format_segment<CharT>& fseg, const Value* value) {
   if (fseg.flags & is_pointer) {
      /* print the value of the pointer */
      out << static_cast<const void*>(value);
   } else if (fseg.flags & is_unsigned) {
      /* print it as an unsigned integer value */
      print_value(out, fseg, reinterpret_cast<std::uintptr_t>(value));
   } else if (fseg.flags & is_integer) {
      /* print it as a signed integer value */
      print_value(out, fseg, reinterpret_cast<std::intptr_t>(value));
   } else {
      out << value;
   }
   return !!out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x24(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x59263
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x82d0
jmp 0x592ca
movq -0x10(%rbp), %rax
movzwl 0x24(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x5928e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdx
callq 0x120d0
jmp 0x592c8
movq -0x10(%rbp), %rax
movzwl 0x24(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x592b9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdx
callq 0x124c0
jmp 0x592c6
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x82d0
jmp 0x592c8
jmp 0x592ca
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x81b0
xorb $-0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x198(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x8320
movq -0x200(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x60b70
movl %eax, -0x1f4(%rbp)
jmp 0x609d2
movl -0x1f4(%rbp), %eax
movl %eax, -0x19c(%rbp)
cmpl $0x0, -0x19c(%rbp)
jge 0x60a16
movl -0x19c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x1b0(%rbp)
jmp 0x60b3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x60b55
cmpq $0x0, -0x18(%rbp)
jne 0x60a35
movl -0x19c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x1b0(%rbp)
jmp 0x60b3d
leaq -0x1d0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x8750
jmp 0x60a4a
movslq -0x19c(%rbp), %rax
addq $0x1, %rax
cmpq -0x18(%rbp), %rax
ja 0x60a99
movq -0x10(%rbp), %rax
movq %rax, -0x208(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x8550
movq -0x208(%rbp), %rdi
movq %rax, %rsi
callq 0x88b0
movl -0x19c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x1b0(%rbp)
jmp 0x60b31
movq -0x10(%rbp), %rax
movq %rax, -0x210(%rbp)
movq -0x18(%rbp), %rcx
decq %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x1f0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x81e0
jmp 0x60ac4
leaq -0x1f0(%rbp), %rdi
callq 0x8550
movq -0x210(%rbp), %rdi
movq %rax, %rsi
callq 0x88b0
leaq -0x1f0(%rbp), %rdi
callq 0x87c0
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
subq $0x1, %rax
movl %eax, -0x4(%rbp)
movl $0x1, -0x1b0(%rbp)
jmp 0x60b31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x87c0
jmp 0x60b55
leaq -0x1d0(%rbp), %rdi
callq 0x87c0
leaq -0x198(%rbp), %rdi
callq 0x86d0
movl -0x4(%rbp), %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
leaq -0x198(%rbp), %rdi
callq 0x86d0
movq -0x1a8(%rbp), %rdi
callq 0x8800
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x61e07
cmpq $0x0, -0x18(%rbp)
jbe 0x61e07
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movb $0x0, %al
callq 0x8700
movl %eax, -0x4(%rbp)
jmp 0x61e27
leaq -0x1030(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movl $0x400, %esi            # imm = 0x400
movb $0x0, %al
callq 0x8700
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xec40
jmp 0x687ca
movq 0x2b7b7(%rip), %rdi     # 0x93f88
leaq -0x28(%rbp), %rsi
callq 0x72a0
movq %rax, -0x60(%rbp)
jmp 0x687e0
movq -0x60(%rbp), %rdi
movq 0x2b7dd(%rip), %rsi     # 0x93fc8
callq 0x7970
jmp 0x687f2
leaq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xf310
jmp 0x68801
leaq -0x50(%rbp), %rdi
callq 0x10a80
leaq -0x28(%rbp), %rdi
callq 0x7b88
jmp 0x6887e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x68838
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x7b88
movl -0x34(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x6889b
movq -0x30(%rbp), %rdi
callq 0x7090
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rsi
movq 0x2b72c(%rip), %rdi     # 0x93f88
callq 0x72a0
movq %rax, -0x68(%rbp)
jmp 0x68867
movq -0x68(%rbp), %rdi
movq 0x2b756(%rip), %rsi     # 0x93fc8
callq 0x7970
jmp 0x68879
callq 0x7710
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x7710
jmp 0x68899
jmp 0x6889b
movq -0x30(%rbp), %rdi
callq 0x7600
movq %rax, %rdi
callq 0xb810
// File: 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
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x250(%rbp)
callq 0x30c0
movq %rax, %rsi
leaq -0x210(%rbp), %rdi
movl $0x10, %edx
callq 0x32b0
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x33c0
movb %al, -0x241(%rbp)
jmp 0x4bd3
movb -0x241(%rbp), %al
testb $0x1, %al
jne 0x4c09
jmp 0x4bdf
movb $0x0, -0x1(%rbp)
movl $0x1, -0x220(%rbp)
jmp 0x4c7d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x4c97
movq -0x250(%rbp), %rsi
leaq -0x240(%rbp), %rdi
callq 0x7ab0
jmp 0x4c1e
leaq -0x210(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x3220
jmp 0x4c33
leaq -0x240(%rbp), %rdi
callq 0x3160
leaq -0x210(%rbp), %rdi
callq 0x3340
jmp 0x4c4d
movb $0x1, -0x1(%rbp)
movl $0x1, -0x220(%rbp)
jmp 0x4c7d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x3160
jmp 0x4c97
leaq -0x210(%rbp), %rdi
callq 0x3360
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
leaq -0x210(%rbp), %rdi
callq 0x3360
movq -0x218(%rbp), %rdi
callq 0x3400
nop
// File: 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
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1c8(%rbp)
movq %rdi, %rax
movq %rax, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1b8(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31a0
movq -0x1b8(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x51d9
leaq -0x190(%rbp), %rdi
leaq 0x1dedb(%rip), %rsi     # 0x23085
callq 0x3250
jmp 0x51b1
jmp 0x52a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x31c0
jmp 0x52d2
leaq -0x190(%rbp), %rdi
leaq 0x1deaa(%rip), %rsi     # 0x23091
callq 0x3250
movq %rax, -0x1d0(%rbp)
jmp 0x51f5
movq -0x1d0(%rbp), %rdi
movq -0x1b8(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x33f0
movq %rax, -0x1d8(%rbp)
jmp 0x5214
movq -0x1d8(%rbp), %rdi
leaq 0x1de74(%rip), %rsi     # 0x23096
callq 0x3250
movq %rax, -0x1e0(%rbp)
jmp 0x5230
movq -0x1e0(%rbp), %rdi
movq -0x1b8(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x33f0
movq %rax, -0x1e8(%rbp)
jmp 0x524f
movq -0x1e8(%rbp), %rdi
leaq 0x1de39(%rip), %rsi     # 0x23096
callq 0x3250
movq %rax, -0x1f0(%rbp)
jmp 0x526b
movq -0x1f0(%rbp), %rdi
movq -0x1b8(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x33f0
movq %rax, -0x1f8(%rbp)
jmp 0x528a
movq -0x1f8(%rbp), %rdi
leaq 0x1e721(%rip), %rsi     # 0x239b9
callq 0x3250
jmp 0x529f
jmp 0x52a1
movq -0x1c8(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x3240
jmp 0x52b6
leaq -0x1a0(%rbp), %rdi
callq 0x31c0
movq -0x1c0(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0x3400
nop
// File: micahcc[P]polygon_skeleton/./simple_svg.hpp
// Function: svg::Line::offset(svg::Point const&)
void offset(Point const & offset)
        {
            start_point.x += offset.x;
            start_point.y += offset.y;

            end_point.x += offset.x;
            end_point.y += offset.y;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
addsd 0x58(%rax), %xmm0
movsd %xmm0, 0x58(%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
addsd 0x60(%rax), %xmm0
movsd %xmm0, 0x60(%rax)
movq -0x10(%rbp), %rcx
movsd (%rcx), %xmm0
addsd 0x68(%rax), %xmm0
movsd %xmm0, 0x68(%rax)
movq -0x10(%rbp), %rcx
movsd 0x8(%rcx), %xmm0
addsd 0x70(%rax), %xmm0
movsd %xmm0, 0x70(%rax)
popq %rbp
retq
nopl (%rax)
// File: micahcc[P]polygon_skeleton/voronoi.cpp
// Function: getSign(Intersection const&)
float getSign(const Intersection& intersection)
{
    assert(intersection.pt_left && intersection.pt_right);

    const Point& left_parab = *intersection.pt_left;
    const Point& right_parab = *intersection.pt_right;
    if(left_parab.y <= right_parab.y) {
        // A = right_parab
        // B = left_parab
        // Transitioning form B to A (B:A)
        return 1;
    } else {
        // A = left_parab
        // B = right_parab
        // Transitioning from A to B (A:B)
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x21(%rbp)
je 0x973a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x9743
jmp 0x9745
jmp 0x9764
leaq 0x19b54(%rip), %rdi     # 0x232a0
leaq 0x19b7b(%rip), %rsi     # 0x232ce
movl $0x1d1, %edx            # imm = 0x1D1
leaq 0x19b7b(%rip), %rcx     # 0x232da
callq 0x3170
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm1
movq -0x20(%rbp), %rax
movss 0x4(%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x97a1
movss 0x19aa6(%rip), %xmm0    # 0x23240
movss %xmm0, -0x4(%rbp)
jmp 0x97ae
movss 0x19a93(%rip), %xmm0    # 0x2323c
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: micahcc[P]polygon_skeleton/./debug.h
// Function: void draw_state<std::set<Intersection, BeachCompare, std::allocator<Intersection>>, CircleQueue>(std::set<Intersection, BeachCompare, std::allocator<Intersection>> const&, CircleQueue const&, double, double)
void draw_state(const IntersectionContainer& intersections,
        const EventContainer& events, double start_sweep_y, double stop_sweep_y)
{
    if(std::isnan(start_sweep_y) || std::isnan(stop_sweep_y))
        return;

    for(double y = start_sweep_y; y > stop_sweep_y; y--)
        draw_state(intersections, events, y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x18150
testb $0x1, %al
jne 0x11af8
movsd -0x20(%rbp), %xmm0
callq 0x18150
testb $0x1, %al
jne 0x11af8
jmp 0x11afa
jmp 0x11b36
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0x11b36
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsd -0x28(%rbp), %xmm0
callq 0x18170
movsd 0x114f6(%rip), %xmm0    # 0x23020
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x11b04
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: micahcc[P]polygon_skeleton/./std_ext.h
// Function: std::hash<std::tuple<Vector const*, Vector const*, Vector const*>>::operator()(std::tuple<Vector const*, Vector const*, Vector const*> const&) const
size_t operator()(const std::tuple<T, T, T>& arg) const
    {
        size_t h1 = std::hash<T>{}(std::get<0>(arg));
        size_t h2 = std::hash<T>{}(std::get<1>(arg));
        size_t h3 = std::hash<T>{}(std::get<2>(arg));
        return h1 ^ (h2 << 1) ^ (h3 << 2);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bc90
movq (%rax), %rsi
leaq -0x19(%rbp), %rdi
callq 0x1bc70
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bcb0
movq (%rax), %rsi
leaq -0x29(%rbp), %rdi
callq 0x1bc70
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bcd0
movq (%rax), %rsi
leaq -0x39(%rbp), %rdi
callq 0x1bc70
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq %rcx
xorq %rcx, %rax
movq -0x38(%rbp), %rcx
shlq $0x2, %rcx
xorq %rcx, %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x3880
movq -0x20(%rbp), %rdi
leaq 0x8b9c(%rip), %rax      # 0xbcf0
movq %rax, (%rdi)
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0x30(%rbp)
addq $0x30, %rdi
movq %rdi, -0x28(%rbp)
callq 0x38a0
movq -0x20(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x40(%rbp)
callq 0x38a0
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x38(%rbp)
callq 0x38a0
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
movl $0x3c, 0x10(%rax)
movl $0x3e8, 0xc(%rax)       # imm = 0x3E8
movl $0x0, 0x14(%rax)
movl $0x3c, 0x18(%rax)
movl $0x0, 0x1c(%rax)
movl $0x18, 0x20(%rax)
movl $0x0, 0x24(%rax)
xorl %esi, %esi
callq 0x38c0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq 0x10(%rax), %rsi
callq 0x3960
jmp 0x31eb
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x48, %rdi
movslq 0x18(%rax), %rsi
callq 0x3960
jmp 0x3201
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x60, %rdi
movslq 0x20(%rax), %rsi
callq 0x3960
jmp 0x3217
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x39f0
movq -0x40(%rbp), %rdi
callq 0x39f0
movq -0x28(%rbp), %rdi
callq 0x39f0
movq -0x20(%rbp), %rdi
callq 0x2c80
movq -0x10(%rbp), %rdi
callq 0x2120
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20f0
movq -0x50(%rbp), %rcx
imulq $0xf4240, -0x18(%rbp), %rax # imm = 0xF4240
addq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
imull $0x3e8, 0x20(%rcx), %ecx # imm = 0x3E8
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20f0
imulq $0xf4240, -0x18(%rbp), %rax # imm = 0xF4240
addq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
subq -0x20(%rbp), %rax
cmpq $0x0, %rax
jle 0x3594
movq -0x28(%rbp), %rax
subq -0x20(%rbp), %rax
movl %eax, %edi
callq 0x20d0
movq -0x50(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2760
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x25f0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3670
testb $0x1, %al
jne 0x35cd
jmp 0x35fc
leaq -0x38(%rbp), %rdi
callq 0x36b0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x48(%rbp)
movq -0x48(%rbp), %rcx
movq (%rcx), %rdi
movl 0x20(%rax), %esi
movq (%rdi), %rax
callq *0x10(%rax)
leaq -0x38(%rbp), %rdi
callq 0x36d0
jmp 0x35ba
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
imull $0x3e8, 0x20(%rcx), %ecx # imm = 0x3E8
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x355a
nopw (%rax,%rax)
// File: BrianYi[P]timer/src/ListNode.h
// Function: ListNode::ListNode()
ListNode()
    {
        timer = NULL;
        hour = 0;
        min = 0;
        sec = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: ruippeixotog[P]algo-lib/simulated-annealing.cpp
// Function: main
int main() {
  srand(time(NULL));

  Sol sol;
  for(int i = 0; i < N; i++) sol.order[i] = i;
  random_shuffle(sol.order, sol.order + N);
  sol.updateScore();

  double avgDist = 0.0;
  for (int i = 0; i < N; i++) {
    for (int j = 0; j < N; j++)
      if (i != j) avgDist += dist[i][j];
  }
  avgDist /= N * (N - 1);

  double maxt = avgDist * 10.0;
  double mint = avgDist * 0.001;
  simulatedAnnealing<Sol, Mut>(sol, maxt, mint, TIMELIMIT);

  printf("%d\n", sol.total);
  return 0;
}

// Assembly:
subq $0x68, %rsp
movl $0x0, 0x64(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1060
movl %eax, %edi
callq 0x1070
movl $0x0, 0x20(%rsp)
cmpl $0xf, 0x20(%rsp)
jge 0x1265
movl 0x20(%rsp), %ecx
movslq 0x20(%rsp), %rax
movl %ecx, 0x24(%rsp,%rax,4)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x1244
leaq 0x24(%rsp), %rdi
leaq 0x24(%rsp), %rsi
addq $0x3c, %rsi
callq 0x1370
leaq 0x24(%rsp), %rdi
callq 0x1420
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0xf, 0x14(%rsp)
jge 0x12fa
movl $0x0, 0x10(%rsp)
cmpl $0xf, 0x10(%rsp)
jge 0x12eb
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
je 0x12dc
movslq 0x14(%rsp), %rcx
leaq 0x2db1(%rip), %rax      # 0x4070
imulq $0x3c, %rcx, %rcx
addq %rcx, %rax
movslq 0x10(%rsp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x12de
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x12a2
jmp 0x12ed
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1293
movsd 0x18(%rsp), %xmm0
movsd 0xd20(%rip), %xmm1      # 0x2028
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0xd06(%rip), %xmm0      # 0x2020
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xcea(%rip), %xmm0      # 0x2018
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
leaq 0x24(%rsp), %rdi
movsd 0xcbf(%rip), %xmm2      # 0x2010
callq 0x14a0
movl 0x60(%rsp), %esi
leaq 0xcdf(%rip), %rdi       # 0x2040
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x68, %rsp
retq
nop
// File: ruippeixotog[P]algo-lib/simulated-annealing.cpp
// Function: Mut::apply(Sol&)
void apply(Sol& sol) {
    int tmp = sol.order[i];
    sol.order[i] = sol.order[(i + 1) % N];
    sol.order[(i + 1) % N] = tmp;

    sol.total += total;
  }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rcx
movslq (%rax), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, -0x14(%rsp)
movq -0x10(%rsp), %rcx
movl (%rax), %eax
addl $0x1, %eax
movl $0xf, %esi
cltd
idivl %esi
movq -0x20(%rsp), %rax
movslq %edx, %rdx
movl (%rcx,%rdx,4), %esi
movq -0x10(%rsp), %rcx
movslq (%rax), %rdx
movl %esi, (%rcx,%rdx,4)
movl -0x14(%rsp), %esi
movq -0x10(%rsp), %rcx
movl (%rax), %eax
addl $0x1, %eax
movl $0xf, %edi
cltd
idivl %edi
movq -0x20(%rsp), %rax
movslq %edx, %rdx
movl %esi, (%rcx,%rdx,4)
movl 0x4(%rax), %ecx
movq -0x10(%rsp), %rax
addl 0x3c(%rax), %ecx
movl %ecx, 0x3c(%rax)
retq
// File: wangyu-[P]pwdgen/main.cpp
// Function: init_table()
int init_table()
{
	int custom_len=strlen(custom_str);
	for(int i=0;i<custom_len;i++)
	{
		unsigned char c= custom_str[i];
		char_table[c]=1;
	}
	return 0;
}

// Assembly:
subq $0x18, %rsp
leaq 0x1155a5(%rip), %rdi    # 0x5178d0
callq 0x4010d8
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x402378
movslq 0x10(%rsp), %rcx
leaq 0x11557e(%rip), %rax    # 0x5178d0
movb (%rax,%rcx), %al
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %eax
movl %eax, %ecx
leaq 0x119c79(%rip), %rax    # 0x51bfe0
movb $0x1, (%rax,%rcx)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x40233c
xorl %eax, %eax
addq $0x18, %rsp
retq
nop
// File: wangyu-[P]pwdgen/lib/md5.cpp
// Function: md5_starts(md5_context*)
void md5_starts( md5_context *ctx )
{
    ctx->total[0] = 0;
    ctx->total[1] = 0;

    ctx->state[0] = 0x67452301;
    ctx->state[1] = 0xEFCDAB89;
    ctx->state[2] = 0x98BADCFE;
    ctx->state[3] = 0x10325476;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, (%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rsp), %rax
movl $0x67452301, 0x8(%rax)  # imm = 0x67452301
movq -0x8(%rsp), %rax
movl $0xefcdab89, 0xc(%rax)  # imm = 0xEFCDAB89
movq -0x8(%rsp), %rax
movl $0x98badcfe, 0x10(%rax) # imm = 0x98BADCFE
movq -0x8(%rsp), %rax
movl $0x10325476, 0x14(%rax) # imm = 0x10325476
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x403ca0
jmp 0x403dc4
movq 0x20(%rsp), %rax
movl (%rax), %eax
andl $0x3f, %eax
movl %eax, 0x4(%rsp)
movl $0x40, %eax
subl 0x4(%rsp), %eax
movl %eax, %eax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl %eax, %ecx
movq 0x20(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
movl (%rax), %ecx
andl $-0x1, %ecx
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
movl (%rax), %eax
movq 0x10(%rsp), %rcx
cmpl %ecx, %eax
jae 0x403cf8
movq 0x20(%rsp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
cmpl $0x0, 0x4(%rsp)
je 0x403d66
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jb 0x403d66
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movl 0x4(%rsp), %eax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x401040
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x18, %rsi
callq 0x402920
movq 0x8(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x4(%rsp)
jmp 0x403d68
cmpq $0x40, 0x10(%rsp)
jb 0x403d9d
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x402920
movq 0x18(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
subq $0x40, %rax
movq %rax, 0x10(%rsp)
jmp 0x403d68
cmpq $0x0, 0x10(%rsp)
jbe 0x403dc4
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movl 0x4(%rsp), %eax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x401040
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xe0(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x402840
leaq 0x8(%rsp), %rdi
callq 0x4028d0
movq 0xf0(%rsp), %rsi
movq 0xe8(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x403c80
movq 0xe0(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x403dd0
leaq 0x8(%rsp), %rdi
callq 0x402860
addq $0xf8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: wangyu-[P]pwdgen/lib/md5.cpp
// Function: md5_hmac_starts(md5_context*, unsigned char const*, unsigned long)
void md5_hmac_starts( md5_context *ctx, const unsigned char *key,
                      size_t keylen )
{
    size_t i;
    unsigned char sum[16];

    if( keylen > 64 )
    {
        md5( key, keylen, sum );
        keylen = 16;
        key = sum;
    }

    memset( ctx->ipad, 0x36, 64 );
    memset( ctx->opad, 0x5C, 64 );

    for( i = 0; i < keylen; i++ )
    {
        ctx->ipad[i] = (unsigned char)( ctx->ipad[i] ^ key[i] );
        ctx->opad[i] = (unsigned char)( ctx->opad[i] ^ key[i] );
    }

    md5_starts( ctx );
    md5_update( ctx, ctx->ipad, 64 );

    polarssl_zeroize( sum, sizeof( sum ) );
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
cmpq $0x40, 0x20(%rsp)
jbe 0x40413e
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rsp, %rdx
callq 0x404080
movq $0x10, 0x20(%rsp)
movq %rsp, %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
addq $0x58, %rdi
movl $0x36, %esi
movl $0x40, %edx
callq 0x401098
movq 0x30(%rsp), %rdi
addq $0x98, %rdi
movl $0x5c, %esi
movl $0x40, %edx
callq 0x401098
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x4041fa
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movzbl 0x58(%rax,%rcx), %eax
movq 0x28(%rsp), %rcx
movq 0x18(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movb %dl, 0x58(%rax,%rcx)
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movzbl 0x98(%rax,%rcx), %eax
movq 0x28(%rsp), %rcx
movq 0x18(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movb %dl, 0x98(%rax,%rcx)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x40417a
movq 0x30(%rsp), %rdi
callq 0x4028d0
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x58, %rsi
movl $0x40, %edx
callq 0x403c80
movq %rsp, %rdi
movl $0x10, %esi
callq 0x402880
addq $0x38, %rsp
retq
nop
// File: wangyu-[P]pwdgen/lib/md5.cpp
// Function: md5_hmac_finish(md5_context*, unsigned char*)
void md5_hmac_finish( md5_context *ctx, unsigned char output[16] )
{
    unsigned char tmpbuf[16];

    md5_finish( ctx, tmpbuf );
    md5_starts( ctx );
    md5_update( ctx, ctx->opad, 64 );
    md5_update( ctx, tmpbuf, 16 );
    md5_finish( ctx, output );

    polarssl_zeroize( tmpbuf, sizeof( tmpbuf ) );
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x403dd0
movq 0x20(%rsp), %rdi
callq 0x4028d0
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x98, %rsi
movl $0x40, %edx
callq 0x403c80
movq 0x20(%rsp), %rdi
movq %rsp, %rsi
movl $0x10, %edx
callq 0x403c80
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x403dd0
movq %rsp, %rdi
movl $0x10, %esi
callq 0x402880
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: wangyu-[P]pwdgen/lib/md5.cpp
// Function: md5_hmac(unsigned char const*, unsigned long, unsigned char const*, unsigned long, unsigned char*)
void md5_hmac( const unsigned char *key, size_t keylen,
               const unsigned char *input, size_t ilen,
               unsigned char output[16] )
{
    md5_context ctx;

    md5_init( &ctx );
    md5_hmac_starts( &ctx, key, keylen );
    md5_hmac_update( &ctx, input, ilen );
    md5_hmac_finish( &ctx, output );
    md5_free( &ctx );
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq %rdx, 0xf0(%rsp)
movq %rcx, 0xe8(%rsp)
movq %r8, 0xe0(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x402840
movq 0x100(%rsp), %rsi
movq 0xf8(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x404100
movq 0xf0(%rsp), %rsi
movq 0xe8(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x404230
movq 0xe0(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x404260
leaq 0x8(%rsp), %rdi
callq 0x402860
addq $0x108, %rsp            # imm = 0x108
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: wangyu-[P]pwdgen/lib/pbkdf2-sha1.cpp
// Function: sha1_starts(sha1_context*)
void sha1_starts(sha1_context * ctx)
{
	ctx->total[0] = 0;
	ctx->total[1] = 0;

	ctx->state[0] = 0x67452301;
	ctx->state[1] = 0xEFCDAB89;
	ctx->state[2] = 0x98BADCFE;
	ctx->state[3] = 0x10325476;
	ctx->state[4] = 0xC3D2E1F0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movq $0x67452301, 0x10(%rax) # imm = 0x67452301
movq -0x8(%rsp), %rax
movl $0xefcdab89, %ecx       # imm = 0xEFCDAB89
movq %rcx, 0x18(%rax)
movq -0x8(%rsp), %rax
movl $0x98badcfe, %ecx       # imm = 0x98BADCFE
movq %rcx, 0x20(%rax)
movq -0x8(%rsp), %rax
movq $0x10325476, 0x28(%rax) # imm = 0x10325476
movq -0x8(%rsp), %rax
movl $0xc3d2e1f0, %ecx       # imm = 0xC3D2E1F0
movq %rcx, 0x30(%rax)
retq
nopw %cs:(%rax,%rax)
// File: wangyu-[P]pwdgen/lib/pbkdf2-sha1.cpp
// Function: sha1_update(sha1_context*, unsigned char const*, int)
void sha1_update(sha1_context * ctx, const unsigned char *input, int ilen)
{
	int fill;
	unsigned long left;

	if (ilen <= 0)
		return;

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

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

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

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

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

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jg 0x40443e
jmp 0x404569
movq 0x20(%rsp), %rax
movq (%rax), %rax
andq $0x3f, %rax
movq %rax, 0x8(%rsp)
movl $0x40, %eax
subq 0x8(%rsp), %rax
movl %eax, 0x10(%rsp)
movslq 0x14(%rsp), %rcx
movq 0x20(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movabsq $0xffffffff, %rcx       # imm = 0xFFFFFFFF
andq (%rax), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movslq 0x14(%rsp), %rcx
cmpq %rcx, %rax
jae 0x4044a5
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rsp)
je 0x404512
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jl 0x404512
movq 0x20(%rsp), %rdi
addq $0x38, %rdi
addq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movslq 0x10(%rsp), %rdx
callq 0x401040
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x38, %rsi
callq 0x404570
movl 0x10(%rsp), %ecx
movq 0x18(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movl 0x10(%rsp), %ecx
movl 0x14(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x14(%rsp)
movq $0x0, 0x8(%rsp)
jmp 0x404514
cmpl $0x40, 0x14(%rsp)
jl 0x404545
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x404570
movq 0x18(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x18(%rsp)
movl 0x14(%rsp), %eax
subl $0x40, %eax
movl %eax, 0x14(%rsp)
jmp 0x404514
cmpl $0x0, 0x14(%rsp)
jle 0x404569
movq 0x20(%rsp), %rdi
addq $0x38, %rdi
addq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movslq 0x14(%rsp), %rdx
callq 0x401040
addq $0x28, %rsp
retq
nop