LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ChanTsune[P]py_string/./py_string.hpp
// Function: py::basic_string<char>::isascii() const
bool basic_string<_Elme>::isascii(void) const
{
  if (this->empty())
    return true;
  for (auto &&s : *this) {
    if (!util::isascii(s))
      return false;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x6770
testb $0x1, %al
jne 0x8a1f
jmp 0x8a25
movb $0x1, -0x1(%rbp)
jmp 0x8a8e
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6460
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6830
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2d540
testb $0x1, %al
jne 0x8a5a
jmp 0x8a8a
leaq -0x20(%rbp), %rdi
callq 0x318b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %edi
callq 0x3b5d0
testb $0x1, %al
jne 0x8a7d
movb $0x0, -0x1(%rbp)
jmp 0x8a8e
jmp 0x8a7f
leaq -0x20(%rbp), %rdi
callq 0x2f3b0
jmp 0x8a47
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: ChanTsune[P]py_string/./py_string.hpp
// Function: py::basic_string<char>::maketrans(py::basic_string<char>, py::basic_string<char>, py::basic_string<char>)
static transtable_t maketrans(basic_string<_Elme> from,
                                basic_string<_Elme> to,
                                basic_string<_Elme> delchars)
  {
    transtable_t table;
    for (int i = std::min(from.size(), to.size()); i--;) {
      table[from[i]] = to[i];
    }
    for (auto &&s : delchars) {
      table[s] = "";
    }
    return table;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rcx, -0x90(%rbp)
movq %rdx, -0x70(%rbp)
movq %rsi, -0x78(%rbp)
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x8c60
movq -0x78(%rbp), %rdi
callq 0x6350
movq -0x70(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x6350
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xf9a0
movq (%rax), %rax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x28(%rbp)
cmpl $0x0, %eax
je 0x8bb0
movq -0x70(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x7dd0
movq %rax, -0x98(%rbp)
jmp 0x8b37
movq -0x78(%rbp), %rdi
movq -0x98(%rbp), %rax
movb (%rax), %al
movb %al, -0xa1(%rbp)
movl -0x28(%rbp), %esi
callq 0x7dd0
movq %rax, -0xa0(%rbp)
jmp 0x8b5b
movq -0xa0(%rbp), %rsi
movq -0x88(%rbp), %rdi
callq 0x3b600
movq %rax, -0xb0(%rbp)
jmp 0x8b77
movq -0xb0(%rbp), %rdi
movb -0xa1(%rbp), %al
movsbl %al, %esi
callq 0x6760
jmp 0x8b8e
jmp 0x8b0e
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x8d10
jmp 0x8c53
movq -0x90(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x6410
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x6290
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x16d50
testb $0x1, %al
jne 0x8be8
jmp 0x8c30
leaq -0x58(%rbp), %rdi
callq 0x16d90
movq -0x88(%rbp), %rdi
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rsi
callq 0x3b600
movq %rax, -0xb8(%rbp)
jmp 0x8c0e
movq -0xb8(%rbp), %rdi
leaq 0x346a1(%rip), %rsi     # 0x3d2bd
callq 0x6660
jmp 0x8c23
jmp 0x8c25
leaq -0x58(%rbp), %rdi
callq 0x16f80
jmp 0x8bd5
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x8c46
movq -0x88(%rbp), %rdi
callq 0x8d10
movq -0x80(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x67e0
nopl (%rax)
// File: ChanTsune[P]py_string/./py_string.hpp
// Function: py::basic_string<char>::translate(std::unordered_map<char, py::basic_string<char>, std::hash<char>, std::equal_to<char>, std::allocator<std::pair<char const, py::basic_string<char>>>>&) const
basic_string<_Elme> basic_string<_Elme>::translate(transtable_t &table) const
{
  basic_string<_Elme> str;
  for (auto &&s : *this) {
    if (table.count(s)) {
      str += table[s];
    } else {
      str.push_back(s);
    }
  }
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x2bf10
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6460
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6830
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2d540
testb $0x1, %al
jne 0x8d9b
jmp 0x8e24
leaq -0x30(%rbp), %rdi
callq 0x318b0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3c9e0
movq %rax, -0x70(%rbp)
jmp 0x8dbb
movq -0x70(%rbp), %rax
cmpq $0x0, %rax
je 0x8e00
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3b600
movq %rax, -0x78(%rbp)
jmp 0x8dd8
movq -0x78(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x65f0
jmp 0x8de7
jmp 0x8e14
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x7db0
jmp 0x8e44
movq -0x68(%rbp), %rdi
movq -0x40(%rbp), %rax
movsbl (%rax), %esi
callq 0x6400
jmp 0x8e12
jmp 0x8e14
jmp 0x8e16
leaq -0x30(%rbp), %rdi
callq 0x2f3b0
jmp 0x8d85
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x8e37
movq -0x68(%rbp), %rdi
callq 0x7db0
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x67e0
nopl (%rax)
// File: ChanTsune[P]py_string/./py_string.hpp
// Function: py::basic_string<char>::slice(py::null_allow::null_allow<int>, py::null_allow::null_allow<int>) const
basic_string<_Elme> basic_string<_Elme>::slice(optional_int start,
                                               optional_int end) const
{
  int s, len;
  std::tie(s, std::ignore, std::ignore, len)
    = util::adjust_index<int>(start, end, this->size());
  return this->substr(s, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x6350
movl %eax, %ecx
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x2b1e0
leaq -0x68(%rbp), %rdi
leaq -0x24(%rbp), %rsi
leaq 0x12cdc(%rip), %rcx     # 0x3dbd1
leaq -0x28(%rbp), %r8
movq %rcx, %rdx
callq 0x2b250
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2b2a0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movslq -0x24(%rbp), %rdx
movslq -0x28(%rbp), %rcx
callq 0x2b2d0
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
// File: ChanTsune[P]py_string/./py_string.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> py::util::itobin<int>(int)
inline std::string itobin(T n)
  {
    std::string str;
    T p = 1;
    for (T i = sizeof(T) * 8; i--;)
      str.push_back(n & (p << i) ? '1' : '0');
    auto pos = str.find('1');
    if (pos != std::string::npos)
      return str.substr(pos);
    return "0";
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6690
movl $0x1, -0x34(%rbp)
movl $0x20, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x38(%rbp)
cmpl $0x0, %eax
je 0x35519
movl -0xc(%rbp), %eax
movl -0x34(%rbp), %edx
movb -0x38(%rbp), %cl
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
subl $0x1, %eax
movl $0x30, %esi
sbbl $-0x1, %esi
leaq -0x30(%rbp), %rdi
callq 0x6400
jmp 0x35506
jmp 0x354d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x355b8
leaq -0x30(%rbp), %rdi
movl $0x31, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6630
movq %rax, -0x50(%rbp)
cmpq $-0x1, -0x50(%rbp)
je 0x35559
movq -0x68(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq -0x30(%rbp), %rsi
movq $-0x1, %rcx
callq 0x64d0
jmp 0x35550
movl $0x1, -0x54(%rbp)
jmp 0x355a5
leaq -0x55(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x67f0
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0x8616(%rip), %rsi      # 0x3db8b
callq 0x6670
jmp 0x3557c
leaq -0x55(%rbp), %rdi
callq 0x6510
movl $0x1, -0x54(%rbp)
jmp 0x355a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x55(%rbp), %rdi
callq 0x6510
jmp 0x355b8
leaq -0x30(%rbp), %rdi
callq 0x62d0
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x62d0
movq -0x40(%rbp), %rdi
callq 0x67e0
nopw (%rax,%rax)
// File: ChanTsune[P]py_string/./py_string.hpp
// Function: py::util::sepinsert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long)
inline void sepinsert(std::string &str, const std::string sep, size_t len)
  {
    std::string dst;
    size_t count = 0;
    auto start = str.rbegin();
    auto end = str.rend();
    for (; start != end; ++start) {
      ++count;
      dst.push_back(*start);
      if (!(count % len)) {
        dst += sep;
      }
    }
    if (dst.back() == sep.back())
      dst.pop_back();
    str.clear();
    std::reverse_copy(dst.begin(), dst.end(), std::back_inserter(str));
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6690
movq $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x67c0
movq -0x8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x6580
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x376f0
movb %al, -0x89(%rbp)
jmp 0x3562e
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x3563d
jmp 0x356c1
movq -0x40(%rbp), %rax
incq %rax
movq %rax, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x37720
movq %rax, -0x98(%rbp)
jmp 0x3565a
movq -0x98(%rbp), %rax
movsbl (%rax), %esi
leaq -0x38(%rbp), %rdi
callq 0x6400
jmp 0x3566f
movq -0x40(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
cmpq $0x0, %rdx
jne 0x356af
movq -0x88(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x65f0
jmp 0x35693
jmp 0x356af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x62d0
jmp 0x35779
jmp 0x356b1
leaq -0x48(%rbp), %rdi
callq 0x37750
jmp 0x356bc
jmp 0x35619
leaq -0x38(%rbp), %rdi
callq 0x6380
movq -0x88(%rbp), %rdi
movsbl (%rax), %eax
movl %eax, -0x9c(%rbp)
callq 0x6210
movq %rax, %rcx
movl -0x9c(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x356f8
leaq -0x38(%rbp), %rdi
callq 0x65b0
movq -0x8(%rbp), %rdi
callq 0x6640
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x6410
movq -0xb0(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x6290
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
callq 0x377f0
movq %rax, -0xa8(%rbp)
jmp 0x35737
movq -0xa8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdx
callq 0x37780
movq %rax, -0xb8(%rbp)
jmp 0x3575c
movq -0xb8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x62d0
addq $0xc0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x67e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ChanTsune[P]py_string/./py_string.hpp
// Function: void py::format_parser::_sign_format<py::basic_string<char>>(py::basic_string<char>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
void _sign_format(T &str, std::string sign, bool negative)
  {
    if (sign == "+") {
      str.insert(0, (negative ? "-" : "+"));
    } else if (sign == " ") {
      str.insert(0, (negative ? "-" : " "));
    } else { // sub.str(4) == "-"
      str.insert(0, (negative ? "-" : ""));
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, %rcx
movq -0x20(%rbp), %rdi
movb %dl, %al
movq %rcx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
leaq 0x736d(%rip), %rsi      # 0x3db96
callq 0x18320
testb $0x1, %al
jne 0x36834
jmp 0x3686f
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, -0x11(%rbp)
je 0x3684f
leaq 0x69d6(%rip), %rax      # 0x3d21f
movq %rax, -0x30(%rbp)
jmp 0x3685c
leaq 0x7340(%rip), %rax      # 0x3db96
movq %rax, -0x30(%rbp)
jmp 0x3685c
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x60e0
jmp 0x368e7
movq -0x20(%rbp), %rdi
leaq 0x731e(%rip), %rsi      # 0x3db98
callq 0x18320
testb $0x1, %al
jne 0x36885
jmp 0x368c0
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, -0x11(%rbp)
je 0x368a0
leaq 0x6985(%rip), %rax      # 0x3d21f
movq %rax, -0x40(%rbp)
jmp 0x368ad
leaq 0x72f1(%rip), %rax      # 0x3db98
movq %rax, -0x40(%rbp)
jmp 0x368ad
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x60e0
jmp 0x368e5
movq -0x8(%rbp), %rdi
movb -0x11(%rbp), %cl
leaq 0x69ef(%rip), %rdx      # 0x3d2bd
leaq 0x694a(%rip), %rax      # 0x3d21f
testb $0x1, %cl
cmovneq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x60e0
jmp 0x368e7
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: ChanTsune[P]py_string/./py_string.hpp
// Function: py::basic_string<char>::center(unsigned long, char) const
basic_string<_Elme> basic_string<_Elme>::center(size_t width,
                                                _Elme fillchar) const
{
  size_t r, l, len = this->size();
  if (width <= len)
    return *this;
  l = width - len;
  r = l / 2 + l % 2;

  return basic_string<_Elme>(l - r, fillchar) + *this
         + basic_string<_Elme>(r, fillchar);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0xf0(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x6350
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x38(%rbp), %rax
ja 0x36dd3
movq -0xe0(%rbp), %rsi
movq -0xf0(%rbp), %rdi
callq 0xa560
jmp 0x36fb9
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, %rax
shrq %rax
andl $0x1, %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x108(%rbp)
movsbl -0x19(%rbp), %eax
movl %eax, -0xfc(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x67f0
movq -0x108(%rbp), %rsi
movl -0xfc(%rbp), %edx
movq -0xf8(%rbp), %rcx
leaq -0x78(%rbp), %rdi
callq 0x2c030
jmp 0x36e41
movq -0xe0(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0xa560
jmp 0x36e56
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x37de0
jmp 0x36e6c
movq -0x28(%rbp), %rax
movq %rax, -0x120(%rbp)
movsbl -0x19(%rbp), %eax
movl %eax, -0x114(%rbp)
leaq -0xd1(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x67f0
movq -0x120(%rbp), %rsi
movl -0x114(%rbp), %edx
movq -0x110(%rbp), %rcx
leaq -0xd0(%rbp), %rdi
callq 0x2c030
jmp 0x36eb6
movq -0xf0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0xd0(%rbp), %rdx
callq 0x37de0
jmp 0x36ecf
leaq -0xd0(%rbp), %rdi
callq 0x7db0
leaq -0xd1(%rbp), %rdi
callq 0x6510
leaq -0x58(%rbp), %rdi
callq 0x7db0
leaq -0xb0(%rbp), %rdi
callq 0x7db0
leaq -0x78(%rbp), %rdi
callq 0x7db0
leaq -0x79(%rbp), %rdi
callq 0x6510
jmp 0x36fb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x36fae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x36fa5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x36f99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x36f84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x7db0
leaq -0xd1(%rbp), %rdi
callq 0x6510
leaq -0x58(%rbp), %rdi
callq 0x7db0
leaq -0xb0(%rbp), %rdi
callq 0x7db0
leaq -0x78(%rbp), %rdi
callq 0x7db0
leaq -0x79(%rbp), %rdi
callq 0x6510
jmp 0x36fc9
movq -0xe8(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x67e0
nopw %cs:(%rax,%rax)
nop
// File: ChanTsune[P]py_string/./py_string.hpp
// Function: unsigned long py::util::decimal_place<float>(float)
inline size_t decimal_place(T x)
  {
    size_t i = 0, j = 10;
    T t = x;
    while (t != std::floor(t)) {
      t = x * j;
      j *= 10;
      ++i;
    }
    return i;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movss %xmm0, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
movq $0xa, -0x18(%rbp)
movss -0x4(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x1c(%rbp), %xmm0
callq 0x37b70
movaps %xmm0, %xmm1
movss -0x20(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jne 0x37aec
jp 0x37aec
jmp 0x37b5c
movss -0x4(%rbp), %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, -0x28(%rbp)
testq %rax, %rax
movss %xmm0, -0x24(%rbp)
js 0x37b2f
movss -0x28(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x2c(%rbp), %xmm0
movss -0x24(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
imulq $0xa, -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x37ac7
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ChanTsune[P]py_string/./py_string.hpp
// Function: py::basic_string<char>::lstrip() const
basic_string<_Elme> basic_string<_Elme>::lstrip(void) const
{
  if (this->empty())
    return *this;
  auto itr = this->begin();
  while (util::isspace(*itr))
    ++itr;
  return this->substr(std::distance(this->begin(), itr));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x6770
testb $0x1, %al
jne 0x3aade
jmp 0x3aaed
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0xa560
jmp 0x3ab55
movq -0x30(%rbp), %rdi
callq 0x6460
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x318b0
movsbl (%rax), %edi
callq 0x3aa50
testb $0x1, %al
jne 0x3ab11
jmp 0x3ab1c
leaq -0x18(%rbp), %rdi
callq 0x2f3b0
jmp 0x3aafa
movq -0x30(%rbp), %rdi
callq 0x6460
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x321a0
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x2b2d0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: ChanTsune[P]py_string/./py_string.hpp
// Function: std::unordered_map<char, py::basic_string<char>, std::hash<char>, std::equal_to<char>, std::allocator<std::pair<char const, py::basic_string<char>>>> py::basic_string<char>::_maketrans<std::unordered_map<char, py::basic_string<char>, std::hash<char>, std::equal_to<char>, std::allocator<std::pair<char const, py::basic_string<char>>>>>(std::unordered_map<char, py::basic_string<char>, std::hash<char>, std::equal_to<char>, std::allocator<std::pair<char const, py::basic_string<char>>>>&)
static transtable_t _maketrans(Map &table_map)
  {
    transtable_t table;
    for (auto &&m : table_map) {
      table[m.first] = m.second;
    }
    return table;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x8c60
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3c830
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3c860
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3c890
testb $0x1, %al
jne 0x3c7a9
jmp 0x3c807
leaq -0x28(%rbp), %rdi
callq 0x3c8c0
movq -0x58(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movq %rsi, %rax
addq $0x8, %rax
movq %rax, -0x68(%rbp)
callq 0x3b600
movq %rax, -0x60(%rbp)
jmp 0x3c7d4
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0x3c8f0
jmp 0x3c7e3
jmp 0x3c7e5
leaq -0x28(%rbp), %rdi
callq 0x3c920
jmp 0x3c796
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x8d10
jmp 0x3c824
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x3c81a
movq -0x58(%rbp), %rdi
callq 0x8d10
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x67e0
nopl (%rax)
// File: TheiaRT[P]libiris/tcp_server.cpp
// Function: TCPServer::~TCPServer()
TCPServer::~TCPServer()
{
    /* Loop thread should be stopped before delete. */
    if (loop_thread->joinable()) {
        /* TODO: decide later if we actually need to join */
        loop_thread->detach();
    }

    delete running;
    delete loop_thread;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x60(%rax), %rdi
callq 0x3650
testb $0x1, %al
jne 0x2623
jmp 0x2634
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x2350
jmp 0x2632
jmp 0x2634
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2654
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x2270
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x267d
movq -0x20(%rbp), %rdi
callq 0x36a0
movq -0x20(%rbp), %rdi
movl $0x8, %esi
callq 0x2270
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x3630
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x3690
nopl (%rax,%rax)
// File: TheiaRT[P]libiris/tcp_server.cpp
// Function: TCPServer::serve_loop()
bool TCPServer::serve_loop()
{
    client_len = sizeof(client_addr);
    std::vector<std::thread *> threads;

    /* While we haven't called ::stop()... */
    while (*running == true) {
        int child_sock = accept(parentsock,
                                (struct sockaddr *) &client_addr,
                                (socklen_t *) &client_len);
        if (child_sock < 0) {
            perror("Could not accept.");
            continue;
        }

        std::thread *tp = new std::thread(
            [=](int sock) {
                dispatch_handler(sock);
            },
            child_sock
        );
        threads.push_back(tp);
    }

    for (std::thread *tp : threads) {
        delete tp;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0x10, 0x30(%rax)
leaq -0x20(%rbp), %rdi
callq 0x3700
movq -0x70(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x3720
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x2a01
movq -0x70(%rbp), %rdx
movl 0x4(%rdx), %edi
movq %rdx, %rsi
addq $0x18, %rsi
addq $0x30, %rdx
callq 0x2090
movl %eax, -0x74(%rbp)
jmp 0x296e
movl -0x74(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x299b
leaq 0x36bc(%rip), %rdi      # 0x603d
callq 0x21e0
jmp 0x2988
jmp 0x2937
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2a97
movl $0x8, %edi
callq 0x2260
movq %rax, -0x80(%rbp)
jmp 0x29ab
movq -0x80(%rbp), %rdi
movq -0x70(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x2ab0
jmp 0x29c6
movq -0x80(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x37a0
jmp 0x29dd
jmp 0x2937
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x8, %esi
callq 0x2270
jmp 0x2a97
leaq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3810
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3840
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3870
testb $0x1, %al
jne 0x2a36
jmp 0x2a81
leaq -0x58(%rbp), %rdi
callq 0x38b0
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, %rax
je 0x2a74
movq -0x88(%rbp), %rdi
callq 0x36a0
movq -0x88(%rbp), %rdi
movl $0x8, %esi
callq 0x2270
jmp 0x2a76
leaq -0x58(%rbp), %rdi
callq 0x38d0
jmp 0x2a23
leaq -0x20(%rbp), %rdi
callq 0x38f0
movb $0x1, %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0x38f0
movq -0x30(%rbp), %rdi
callq 0x2360
nopl (%rax)
// File: TheiaRT[P]libiris/tcp_server.cpp
// Function: TCPServer::dispatch_handler(int)
bool TCPServer::dispatch_handler(int client)
{
    std::string req = "";
    if (read_from_sock(client, req, timeout_microsec) == false) {
        /* No failure/recovery plan yet. */
        perror("read_from_sock failed.");
        return false;
    }

    /* Handle the client's request. */
    std::string response = handler(req);

    /* Write some response back. */
    int nwritten = send(client, response.c_str(), response.length(), 0);
    if (nwritten < 0 || nwritten != response.length()) {
        perror("Could not write to socket.");
        return false;
    }

    close(client);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x2370
movq -0xa0(%rbp), %rdx
leaq 0x3665(%rip), %rsi      # 0x6210
leaq -0x38(%rbp), %rdi
callq 0x3950
jmp 0x2bb6
leaq -0x39(%rbp), %rdi
callq 0x22a0
movq -0xa8(%rbp), %rax
movl -0x14(%rbp), %edi
movq 0x28(%rax), %rdx
leaq -0x38(%rbp), %rsi
callq 0x2da0
movb %al, -0xa9(%rbp)
jmp 0x2bde
movb -0xa9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2c37
leaq 0x345a(%rip), %rdi      # 0x604f
callq 0x21e0
jmp 0x2bfc
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x2d72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x22a0
jmp 0x2d92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2d89
movq -0xa8(%rbp), %rax
addq $0x38, %rax
movq %rax, -0xb8(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x20f0
jmp 0x2c5b
movq -0xb8(%rbp), %rsi
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x3a00
jmp 0x2c74
leaq -0x90(%rbp), %rdi
callq 0x2170
movl -0x14(%rbp), %eax
movl %eax, -0xcc(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x20e0
movq -0xd8(%rbp), %rdi
movq %rax, -0xc8(%rbp)
callq 0x2310
movl -0xcc(%rbp), %edi
movq -0xc8(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x2120
movq %rax, -0xc0(%rbp)
jmp 0x2ccc
movq -0xc0(%rbp), %rax
movl %eax, -0x94(%rbp)
cmpl $0x0, -0x94(%rbp)
jl 0x2d08
movslq -0x94(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2310
movq %rax, %rcx
movq -0xe0(%rbp), %rax
cmpq %rcx, %rax
je 0x2d54
leaq 0x3357(%rip), %rdi      # 0x6066
callq 0x21e0
jmp 0x2d16
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x2d69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x2170
jmp 0x2d89
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2170
jmp 0x2d89
movl -0x14(%rbp), %edi
callq 0x23a0
jmp 0x2d5e
movb $0x1, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2170
leaq -0x38(%rbp), %rdi
callq 0x2170
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x2170
movq -0x48(%rbp), %rdi
callq 0x2360
nopl (%rax,%rax)
// File: TheiaRT[P]libiris/sampleserver.cpp
// Function: main
int main() {
    TCPServer *server = new TCPServer(reverse_request);
    if (server->start("localhost", 8000) == false) {
        std::cerr << "Could not start server." << std::endl;
        return 1;
    }
    std::cerr << "Listening on localhost:8000..." << std::endl;
    while (1) {
        sleep(1);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
movl $0x68, %edi
callq 0x2260
movq %rax, -0x78(%rbp)
movq %rax, -0x80(%rbp)
movb $0x1, -0x3d(%rbp)
leaq -0xbf(%rip), %rsi       # 0x4bf0
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x4e70
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movl $0x186a0, %edx          # imm = 0x186A0
callq 0x2570
jmp 0x4cd0
movb $0x0, -0x3d(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3630
movq -0x80(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2370
movq -0x88(%rbp), %rdx
leaq 0x14c2(%rip), %rsi      # 0x61d0
leaq -0x60(%rbp), %rdi
callq 0x3950
jmp 0x4d19
movq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x1f40, %edx           # imm = 0x1F40
movl $0x5, %ecx
callq 0x26a0
movb %al, -0x91(%rbp)
jmp 0x4d3b
movb -0x91(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x98(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2170
leaq -0x61(%rbp), %rdi
callq 0x22a0
movl -0x98(%rbp), %eax
cmpl $0x0, %eax
jne 0x4df8
movq 0x527c(%rip), %rdi      # 0x9ff0
leaq 0x145f(%rip), %rsi      # 0x61da
callq 0x2250
movq %rax, %rdi
movq 0x5236(%rip), %rsi      # 0x9fc0
callq 0x2280
movl $0x1, %eax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3630
testb $0x1, -0x3d(%rbp)
jne 0x4dba
jmp 0x4dc8
movq -0x80(%rbp), %rdi
movl $0x68, %esi
callq 0x2270
jmp 0x4e26
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x4ded
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2170
leaq -0x61(%rbp), %rdi
callq 0x22a0
jmp 0x4e26
movq 0x51f1(%rip), %rdi      # 0x9ff0
leaq 0x13ec(%rip), %rsi      # 0x61f2
callq 0x2250
movq %rax, %rdi
movq 0x51ab(%rip), %rsi      # 0x9fc0
callq 0x2280
movl $0x1, %edi
callq 0x21a0
jmp 0x4e1a
movq -0x38(%rbp), %rdi
callq 0x2360
nop
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mp_get_memory_functions
void
mp_get_memory_functions (void *(**alloc_func) (size_t),
			 void *(**realloc_func) (void *, size_t, size_t),
			 void (**free_func) (void *, size_t))
{
  if (alloc_func)
    *alloc_func = gmp_allocate_func;

  if (realloc_func)
    *realloc_func = gmp_reallocate_func;

  if (free_func)
    *free_func = gmp_free_func;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1215
movq 0x11e7a(%rip), %rcx     # 0x13088
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x10(%rbp)
je 0x122a
movq 0x11e6d(%rip), %rcx     # 0x13090
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x123f
movq 0x11e60(%rip), %rcx     # 0x13098
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mp_set_memory_functions
void
mp_set_memory_functions (void *(*alloc_func) (size_t),
			 void *(*realloc_func) (void *, size_t, size_t),
			 void (*free_func) (void *, size_t))
{
  if (!alloc_func)
    alloc_func = gmp_default_alloc;
  if (!realloc_func)
    realloc_func = gmp_default_realloc;
  if (!free_func)
    free_func = gmp_default_free;

  gmp_allocate_func = alloc_func;
  gmp_reallocate_func = realloc_func;
  gmp_free_func = free_func;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1272
leaq 0x52(%rip), %rax        # 0x12c0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1284
leaq 0xa0(%rip), %rax        # 0x1320
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1296
leaq 0xde(%rip), %rax        # 0x1370
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0x11de7(%rip)     # 0x13088
movq -0x10(%rbp), %rax
movq %rax, 0x11de4(%rip)     # 0x13090
movq -0x18(%rbp), %rax
movq %rax, 0x11de1(%rip)     # 0x13098
popq %rbp
retq
nopl (%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: gmp_default_alloc
static void *
gmp_default_alloc (size_t size)
{
  void *p;

  assert (size > 0);

  p = malloc (size);
  if (!p)
    gmp_die("gmp_default_alloc: Virtual memory exhausted.");

  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jbe 0x12d5
jmp 0x12f4
leaq 0xe52d(%rip), %rdi      # 0xf809
leaq 0xcdf1(%rip), %rsi      # 0xe0d4
movl $0xff, %edx
leaq 0xe06b(%rip), %rcx      # 0xf35a
callq 0x1070
movq -0x8(%rbp), %rdi
callq 0x1090
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1314
leaq 0xe06b(%rip), %rdi      # 0xf37a
callq 0x7b50
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: gmp_default_realloc
static void *
gmp_default_realloc (void *old, size_t old_size, size_t new_size)
{
  void * p;

  p = realloc (old, new_size);

  if (!p)
    gmp_die("gmp_default_realloc: Virtual memory exhausted.");

  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1358
leaq 0xe054(%rip), %rdi      # 0xf3a7
callq 0x7b50
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_cmp
int
mpn_cmp (mp_srcptr ap, mp_srcptr bp, mp_size_t n)
{
  while (--n >= 0)
    {
      if (ap[n] != bp[n])
	return ap[n] > bp[n] ? 1 : -1;
    }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jl 0x148b
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x1489
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
cmpq %rsi, %rdx
cmoval %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1492
jmp 0x1430
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_add_1
mp_limb_t
mpn_add_1 (mp_ptr rp, mp_srcptr ap, mp_size_t n, mp_limb_t b)
{
  mp_size_t i;

  assert (n > 0);
  i = 0;
  do
    {
      mp_limb_t r = ap[i] + b;
      /* Carry out */
      b = (r < b);
      rp[i] = r;
    }
  while (++i < n);

  return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0x1581
jmp 0x15a0
leaq 0xe0ad(%rip), %rdi      # 0xf635
leaq 0xcb45(%rip), %rsi      # 0xe0d4
movl $0x18f, %edx            # imm = 0x18F
leaq 0xcb4f(%rip), %rcx      # 0xe0ea
callq 0x1070
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
cmpq -0x18(%rbp), %rax
jl 0x15a8
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_add_n
mp_limb_t
mpn_add_n (mp_ptr rp, mp_srcptr ap, mp_srcptr bp, mp_size_t n)
{
  mp_size_t i;
  mp_limb_t cy;

  for (i = 0, cy = 0; i < n; i++)
    {
      mp_limb_t a, b, r;
      a = ap[i]; b = bp[i];
      r = a + cy;
      cy = (r < cy);
      r += b;
      cy += (r < b);
      rp[i] = r;
    }
  return cy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x16bb
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x30(%rbp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1624
movq -0x30(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_add
mp_limb_t
mpn_add (mp_ptr rp, mp_srcptr ap, mp_size_t an, mp_srcptr bp, mp_size_t bn)
{
  mp_limb_t cy;

  assert (an >= bn);

  cy = mpn_add_n (rp, ap, bp, bn);
  if (an > bn)
    cy = mpn_add_1 (rp + bn, ap + bn, an - bn, cy);
  return cy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jl 0x16f8
jmp 0x1717
leaq 0xca28(%rip), %rdi      # 0xe127
leaq 0xc9ce(%rip), %rsi      # 0xe0d4
movl $0x1b5, %edx            # imm = 0x1B5
leaq 0xca1e(%rip), %rcx      # 0xe130
callq 0x1070
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1600
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jle 0x176d
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
subq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x1560
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_sub_1
mp_limb_t
mpn_sub_1 (mp_ptr rp, mp_srcptr ap, mp_size_t n, mp_limb_t b)
{
  mp_size_t i;

  assert (n > 0);

  i = 0;
  do
    {
      mp_limb_t a = ap[i];
      /* Carry out */
      mp_limb_t cy = a < b;;
      rp[i] = a - b;
      b = cy;
    }
  while (++i < n);

  return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0x17a1
jmp 0x17c0
leaq 0xde8d(%rip), %rdi      # 0xf635
leaq 0xc925(%rip), %rsi      # 0xe0d4
movl $0x1c2, %edx            # imm = 0x1C2
leaq 0xc9bb(%rip), %rcx      # 0xe176
callq 0x1070
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdx
subq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
cmpq -0x18(%rbp), %rax
jl 0x17c8
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_sub_n
mp_limb_t
mpn_sub_n (mp_ptr rp, mp_srcptr ap, mp_srcptr bp, mp_size_t n)
{
  mp_size_t i;
  mp_limb_t cy;

  for (i = 0, cy = 0; i < n; i++)
    {
      mp_limb_t a, b;
      a = ap[i]; b = bp[i];
      b += cy;
      cy = (b < cy);
      cy += (a < b);
      rp[i] = a - b;
    }
  return cy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x18e3
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x30(%rbp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rdx
subq -0x40(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1854
movq -0x30(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_sub
mp_limb_t
mpn_sub (mp_ptr rp, mp_srcptr ap, mp_size_t an, mp_srcptr bp, mp_size_t bn)
{
  mp_limb_t cy;

  assert (an >= bn);

  cy = mpn_sub_n (rp, ap, bp, bn);
  if (an > bn)
    cy = mpn_sub_1 (rp + bn, ap + bn, an - bn, cy);
  return cy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jl 0x1918
jmp 0x1937
leaq 0xc808(%rip), %rdi      # 0xe127
leaq 0xc7ae(%rip), %rsi      # 0xe0d4
movl $0x1e9, %edx            # imm = 0x1E9
leaq 0xc881(%rip), %rcx      # 0xe1b3
callq 0x1070
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x1830
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jle 0x198d
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
subq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x1780
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_mul_1
mp_limb_t
mpn_mul_1 (mp_ptr rp, mp_srcptr up, mp_size_t n, mp_limb_t vl)
{
  mp_limb_t ul, cl, hpl, lpl;

  assert (n >= 1);

  cl = 0;
  do
    {
      ul = *up++;
      gmp_umul_ppmm (hpl, lpl, ul, vl);

      lpl += cl;
      cl = (lpl < cl) + hpl;

      *rp++ = lpl;
    }
  while (--n != 0);

  return cl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x1, -0x18(%rbp)
jl 0x19c4
jmp 0x19e3
leaq 0xc93b(%rip), %rdi      # 0xe306
leaq 0xc702(%rip), %rsi      # 0xe0d4
movl $0x1f6, %edx            # imm = 0x1F6
leaq 0xc81b(%rip), %rcx      # 0xe1f9
callq 0x1070
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x78(%rbp), %rax
movl %eax, -0x64(%rbp)
movq -0x78(%rbp), %rax
shrq $0x20, %rax
movl %eax, -0x6c(%rbp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x80(%rbp), %rax
movl %eax, -0x68(%rbp)
movq -0x80(%rbp), %rax
shrq $0x20, %rax
movl %eax, -0x70(%rbp)
movl -0x64(%rbp), %eax
movl -0x68(%rbp), %ecx
imulq %rcx, %rax
movq %rax, -0x48(%rbp)
movl -0x64(%rbp), %eax
movl -0x70(%rbp), %ecx
imulq %rcx, %rax
movq %rax, -0x50(%rbp)
movl -0x6c(%rbp), %eax
movl -0x68(%rbp), %ecx
imulq %rcx, %rax
movq %rax, -0x58(%rbp)
movl -0x6c(%rbp), %eax
movl -0x70(%rbp), %ecx
imulq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rax
shrq $0x20, %rax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x58(%rbp), %rax
jae 0x1ab9
movabsq $0x100000000, %rax      # imm = 0x100000000
addq -0x60(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq -0x50(%rbp), %rcx
shrq $0x20, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x50(%rbp), %rax
shlq $0x20, %rax
movabsq $0xffffffff, %rcx       # imm = 0xFFFFFFFF
andq -0x48(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x30(%rbp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
addq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x8(%rbp)
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x19eb
movq -0x30(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_addmul_1
mp_limb_t
mpn_addmul_1 (mp_ptr rp, mp_srcptr up, mp_size_t n, mp_limb_t vl)
{
  mp_limb_t ul, cl, hpl, lpl, rl;

  assert (n >= 1);

  cl = 0;
  do
    {
      ul = *up++;
      gmp_umul_ppmm (hpl, lpl, ul, vl);

      lpl += cl;
      cl = (lpl < cl) + hpl;

      rl = *rp;
      lpl = rl + lpl;
      cl += lpl < rl;
      *rp++ = lpl;
    }
  while (--n != 0);

  return cl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x1, -0x18(%rbp)
jl 0x1b74
jmp 0x1b93
leaq 0xc78b(%rip), %rdi      # 0xe306
leaq 0xc552(%rip), %rsi      # 0xe0d4
movl $0x20d, %edx            # imm = 0x20D
leaq 0xc6a8(%rip), %rcx      # 0xe236
callq 0x1070
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x80(%rbp), %rax
movl %eax, -0x6c(%rbp)
movq -0x80(%rbp), %rax
shrq $0x20, %rax
movl %eax, -0x74(%rbp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x88(%rbp), %rax
movl %eax, -0x70(%rbp)
movq -0x88(%rbp), %rax
shrq $0x20, %rax
movl %eax, -0x78(%rbp)
movl -0x6c(%rbp), %eax
movl -0x70(%rbp), %ecx
imulq %rcx, %rax
movq %rax, -0x50(%rbp)
movl -0x6c(%rbp), %eax
movl -0x78(%rbp), %ecx
imulq %rcx, %rax
movq %rax, -0x58(%rbp)
movl -0x74(%rbp), %eax
movl -0x70(%rbp), %ecx
imulq %rcx, %rax
movq %rax, -0x60(%rbp)
movl -0x74(%rbp), %eax
movl -0x78(%rbp), %ecx
imulq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rax
shrq $0x20, %rax
addq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x60(%rbp), %rax
addq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x60(%rbp), %rax
jae 0x1c72
movabsq $0x100000000, %rax      # imm = 0x100000000
addq -0x68(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq -0x58(%rbp), %rcx
shrq $0x20, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x58(%rbp), %rax
shlq $0x20, %rax
movabsq $0xffffffff, %rcx       # imm = 0xFFFFFFFF
andq -0x50(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x30(%rbp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
addq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x8(%rbp)
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1b9b
movq -0x30(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)