LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/ChanTsune[P]py_string/./py_string.hpp
// Function: void py::basic_string<char>::split<std::deque<py::basic_string<char>, std::allocator<py::basic_string<char>>>>(std::deque<py::basic_string<char>, std::allocator<py::basic_string<char>>>&, py::basic_string<char>, unsigned long) const
void basic_string<_Elme>::split(_Iterable &result, basic_string<_Elme> sep,
                                size_t maxsplit) const
{
  if (sep.empty())
    return this->split(result, maxsplit);
  if (result.size() != 0)
    result.clear();
  size_t index, pre_index = 0, sep_len = sep.size();
  for (; maxsplit--;) {
    index = this->find(sep, pre_index);
    if (index == std::basic_string<_Elme>::npos)
      break;
    result.push_back(this->substr(pre_index, index - pre_index));
    pre_index = index + sep_len;
  }
  result.push_back(this->substr(pre_index));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, -0x38(%rbp)
cmpq $0x0, 0x8(%rdx)
je 0x619e
movq 0x48(%rbx), %rax
movq %rax, %rcx
subq 0x28(%rbx), %rcx
shrq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
shlq $0x4, %rcx
movq 0x20(%rbx), %rax
movq 0x30(%rbx), %rdx
subq 0x38(%rbx), %rdx
sarq $0x5, %rdx
addq %rcx, %rdx
subq 0x10(%rbx), %rax
sarq $0x5, %rax
addq %rdx, %rax
je 0x6116
movq %rbx, %rdi
callq 0x1a998
movq %rbx, -0x30(%rbp)
testq %r15, %r15
je 0x61ba
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
xorl %ebx, %ebx
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4500
cmpq $-0x1, %rax
je 0x61bf
movq %rax, %r13
movq %rax, %rcx
subq %rbx, %rcx
movq %r14, %rsi
leaq -0x58(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rdx
callq 0x124f4
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x1ad66
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x618d
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x42d0
decq %r15
addq -0x60(%rbp), %r13
movq %r13, %rbx
testq %r15, %r15
jne 0x6131
jmp 0x61c2
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1a768
xorl %r13d, %r13d
jmp 0x61c2
movq %rbx, %r13
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq $-0x1, %rcx
callq 0x124f4
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x1ad66
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6200
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x42d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
jmp 0x6227
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x6238
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, -0x30(%rbp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movups %xmm0, 0x28(%rdi)
movq 0x8(%rsi), %rax
movq 0x8(%rdx), %rcx
cmpq %rax, %rcx
cmovbq %rcx, %rax
cltq
movq %rax, %r13
subq $0x1, %r13
jb 0x62de
jge 0x62a3
movq 0x8(%r15), %rdx
movq 0x8(%r12), %rcx
jmp 0x62a7
xorl %edx, %edx
xorl %ecx, %ecx
addq (%r15), %rdx
movb -0x1(%rax,%rdx), %r14b
addq (%r12), %rcx
leaq (%rax,%rcx), %rsi
decq %rsi
movq %rbx, %rdi
callq 0x1aec8
movq 0x8(%rax), %rdx
movsbl %r14b, %r8d
movl $0x1, %ecx
movq %rax, %rdi
xorl %esi, %esi
callq 0x4540
movq %r13, %rax
jmp 0x6290
movq -0x30(%rbp), %rax
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x631c
movq (%rax), %r14
leaq 0x15f82(%rip), %r15     # 0x1c277
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1aec8
movq 0x8(%rax), %rdx
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x4460
incq %r14
decq %r12
jne 0x62f5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6330
movq %rax, %r14
movq %rbx, %rdi
callq 0x695a
movq %r14, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r13
testq %r13, %r13
je 0x63b7
movq %rdx, %r14
movq (%rsi), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1b330
testq %rax, %rax
je 0x63a3
movq %r14, %rdi
movq %r15, %rsi
callq 0x1aec8
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x40c0
jmp 0x63af
movsbl (%r15), %esi
movq %rbx, %rdi
callq 0x4280
incq %r15
decq %r13
jne 0x6377
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x63e0
movq (%r12), %rsi
incq %rsi
callq 0x42d0
movq %r14, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $0x100000000, %r8       # imm = 0x100000000
movl 0x8(%rsi), %eax
xorl %edi, %edi
btq $0x20, %rdx
jae 0x12483
testl %edx, %edx
js 0x1247a
cmpl %edx, %eax
cmovll %eax, %edx
movl %edx, %edi
jmp 0x12483
addl %eax, %edx
xorl %edi, %edi
testl %edx, %edx
cmovgl %edx, %edi
testq %r8, %rcx
je 0x1249e
testl %ecx, %ecx
js 0x12495
cmpl %ecx, %eax
cmovll %eax, %ecx
movl %ecx, %eax
jmp 0x1249e
addl %ecx, %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %ecx, %ecx
subl %edi, %eax
cmovlel %ecx, %eax
movslq %edi, %rdx
movslq %eax, %rcx
movq %rbx, %rdi
callq 0x124f4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movl $0x1f, %eax
leaq -0x48(%rbp), %r15
cmpl $-0x1, %eax
je 0x162e8
leal -0x1(%rax), %r13d
btl %eax, %r14d
movl $0x0, %esi
adcl $0x30, %esi
movq %r15, %rdi
callq 0x4280
movl %r13d, %eax
jmp 0x162c6
leaq -0x48(%rbp), %rdi
movl $0x31, %esi
xorl %edx, %edx
callq 0x43d0
cmpq $-0x1, %rax
je 0x16316
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x4300
jmp 0x16333
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x683b(%rip), %rsi      # 0x1cb5f
leaq 0x6835(%rip), %rdx      # 0x1cb60
movq %rbx, %rdi
callq 0x6436
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x16348
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1635e
jmp 0x1635e
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x16376
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x58(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rdi, -0x50(%rbp)
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x16410
movq %rdx, %r15
movq -0x50(%rbp), %rax
movq (%rax), %rax
leaq (%rbx,%rax), %r14
decq %r14
negq %rbx
movl $0x1, %r12d
leaq -0x48(%rbp), %r13
movsbl (%r14), %esi
movq %r13, %rdi
callq 0x4280
movq %r12, %rax
xorl %edx, %edx
divq %r15
testq %rdx, %rdx
jne 0x163fd
movq -0x58(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r13, %rdi
callq 0x40c0
leaq (%rbx,%r12), %rax
incq %rax
incq %r12
decq %r14
cmpq $0x1, %rax
jne 0x163d1
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
movb -0x1(%rax,%rcx), %al
movq -0x58(%rbp), %rdx
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
cmpb -0x1(%rcx,%rdx), %al
jne 0x16436
leaq -0x48(%rbp), %rdi
callq 0x4390
movq -0x50(%rbp), %r15
movq $0x0, 0x8(%r15)
movq (%r15), %rax
movb $0x0, (%rax)
movq -0x40(%rbp), %rbx
testq %rbx, %rbx
je 0x16468
movq -0x48(%rbp), %r14
movsbl -0x1(%r14,%rbx), %esi
movq %r15, %rdi
callq 0x4280
decq %rbx
jne 0x16455
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x16481
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x42d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16492
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x164ae
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x58b4(%rip), %r15      # 0x1cb6a
movq %rsi, %rdi
movq %r15, %rsi
callq 0x40b0
testl %eax, %eax
je 0x172fd
leaq 0x58a0(%rip), %r15      # 0x1cb6c
movq %r12, %rdi
movq %r15, %rsi
callq 0x40b0
testl %eax, %eax
je 0x172fd
leaq 0x4ecd(%rip), %rax      # 0x1c1af
leaq 0x4f8e(%rip), %rcx      # 0x1c277
testb %r14b, %r14b
cmovneq %rax, %rcx
movzbl %r14b, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
jmp 0x1731b
leaq 0x4eab(%rip), %rax      # 0x1c1af
testb %r14b, %r14b
cmovneq %rax, %r15
movl $0x1, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4330
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
subq %rdx, %r14
jbe 0x17946
movq %r14, %r12
shrq %r12
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movsbl %cl, %r15d
leaq -0x48(%rbp), %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x4370
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x688c
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x40c0
subq %r12, %r14
leaq -0x78(%rbp), %r12
movq %r12, -0x10(%r12)
movq -0x48(%rbp), %rax
leaq -0x38(%rbp), %rcx
cmpq %rcx, %rax
je 0x17961
movq %rax, -0x88(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0x17969
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r13), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x688c
jmp 0x17a19
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq -0x40(%rbp), %rax
movq %rax, -0x80(%rbp)
movq %rcx, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
leaq -0x98(%rbp), %r13
movq %r13, -0x10(%r13)
leaq -0xa8(%rbp), %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x4370
leaq -0x88(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
movq %rbx, %rdi
callq 0x17df8
movq -0xa8(%rbp), %rdi
cmpq %r13, %rdi
je 0x179cf
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x42d0
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x179e7
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x42d0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x17a00
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x42d0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x17a19
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0xa8(%rbp), %rdi
cmpq %r13, %rdi
je 0x17a51
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x42d0
jmp 0x17a51
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x17a6e
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x42d0
jmp 0x17a6e
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x17a8c
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x42d0
jmp 0x17a8c
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x17aa5
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0x1aa1d
movq (%rsi), %rax
xorl %edx, %edx
movabsq $0x1f0003e00, %rcx      # imm = 0x1F0003E00
movzbl (%rax,%rdx), %edi
cmpq $0x20, %rdi
ja 0x1aa0c
btq %rdi, %rcx
jae 0x1aa0c
incq %rdx
jmp 0x1a9f7
movq %rbx, %rdi
movq $-0x1, %rcx
callq 0x124f4
jmp 0x1aa32
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rsi), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x688c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movups %xmm0, 0x28(%rdi)
addq $0x10, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x1b314
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x1aec8
leaq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x41a0
jmp 0x1b2f2
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x695a
movq %r14, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
cmpq $0x0, (%rdi)
je 0x2469
callq 0x2220
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x247c
movl $0x1, %esi
callq 0x21c0
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x2495
cmpq $0x0, (%rdi)
jne 0x24b1
movl $0x8, %esi
callq 0x21c0
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x24af
addq $0x38, %rbx
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
popq %rbx
retq
callq 0x2070
jmp 0x24b8
movq %rax, %rdi
callq 0x2b1f
// File: /workspace/github_cpp_makefile_star2_O1/TheiaRT[P]libiris/tcp_server.cpp
// Function: TCPServer::start(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
bool TCPServer::start(std::string host, int port, int backlog)
{
    /* Open a new socket for the server. */
    if ((parentsock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("Could not open socket.");
        return false;
    }

    /* Can re-run immediately after kill, instead of waiting. */
    optval = 1;
    setsockopt(parentsock, SOL_SOCKET, SO_REUSEADDR,
               (const void *)&optval, sizeof(optval));

    /* Zero out the server_addr. */
    bzero((char *) &server_addr, sizeof(server_addr));

    server_addr.sin_family = AF_INET;
    /* Let the system figure out our IP address. */
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons((unsigned short) port);

    /* Bind to the port. */
    if (bind(parentsock,
             (struct sockaddr *) &server_addr,
             sizeof(server_addr)) < 0) {
        perror("Could not bind.");
        return false;
    }

    /* Listen on the port with a backlog of up to backlog connections. */
    if (listen(parentsock, backlog) < 0) {
        perror("Could not listen.");
        return false;
    }

    /* Make the loop thread runnable. */
    *running = true;

    /* Start the loop! Go! */
    loop_thread = new std::thread([=] { serve_loop(); });
    return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %rbx
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2060
movl %eax, 0x4(%rbx)
testl %eax, %eax
js 0x25b2
movl $0x1, (%rbx)
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movq %rbx, %rcx
movl $0x4, %r8d
callq 0x2240
leaq 0x8(%rbx), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movw $0x2, 0x8(%rbx)
movl $0x0, 0xc(%rbx)
rolw $0x8, %r14w
movw %r14w, 0xa(%rbx)
movl 0x4(%rbx), %edi
movl $0x10, %edx
callq 0x2050
testl %eax, %eax
js 0x25bb
movl 0x4(%rbx), %edi
movl %ebp, %esi
callq 0x21d0
testl %eax, %eax
js 0x25c4
movq 0x58(%rbx), %rax
movb $0x1, %cl
xchgb %cl, (%rax)
movl $0x8, %edi
callq 0x21b0
movq %rax, %r14
movq $0x0, (%rax)
movl $0x10, %edi
callq 0x21b0
leaq 0x379e(%rip), %rcx      # 0x5d18
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, %rdi
xorl %edx, %edx
callq 0x2180
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x25a3
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, 0x60(%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1a4b(%rip), %rdi      # 0x4004
jmp 0x25cb
leaq 0x1a59(%rip), %rdi      # 0x401b
jmp 0x25cb
leaq 0x1a60(%rip), %rdi      # 0x402b
callq 0x2160
xorl %eax, %eax
jmp 0x25a9
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x25e7
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x25f5
movq %rax, %rbx
movl $0x8, %esi
movq %r14, %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl $0x10, 0x30(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x58(%rdi), %rax
movb (%rax), %al
testb $0x1, %al
je 0x270c
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
leaq 0x18(%rdi), %r15
leaq 0x8(%rsp), %r13
movl 0x4(%rbx), %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2080
movl %eax, %r12d
testl %eax, %eax
js 0x26fe
movl $0x8, %edi
callq 0x21b0
movq %rax, %rbp
movq $0x0, (%rax)
movl $0x18, %edi
callq 0x21b0
leaq 0x36c2(%rip), %rcx      # 0x5d58
movq %rcx, (%rax)
movl %r12d, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rax, 0x8(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x2180
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x26c3
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbp, 0x30(%rsp)
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x26df
movq %rbp, (%rsi)
addq $0x8, 0x18(%rsp)
jmp 0x26ee
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x2bba
movq 0x58(%rbx), %rax
movb (%rax), %al
testb $0x1, %al
jne 0x2658
jmp 0x270c
leaq 0x1938(%rip), %rdi      # 0x403d
callq 0x2160
jmp 0x26ee
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r14
cmpq %r14, %rbx
je 0x2739
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2733
cmpq $0x0, (%rdi)
jne 0x2761
movl $0x8, %esi
callq 0x21c0
addq $0x8, %rbx
jmp 0x2716
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2750
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21c0
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2070
movq %rax, %rbx
jmp 0x2787
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x277e
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movl $0x8, %esi
movq %rbp, %rdi
callq 0x21c0
jmp 0x279b
jmp 0x2798
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x27b2
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl $0x68, %edi
callq 0x21b0
movq %rax, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
leaq -0x8f(%rip), %rax       # 0x2d88
movq %rax, (%rsi)
leaq 0x179(%rip), %rax       # 0x2f9a
movq %rax, 0x18(%rsi)
leaq 0x17c(%rip), %rax       # 0x2fa8
movq %rax, 0x10(%rsi)
movl $0x186a0, %edx          # imm = 0x186A0
movq %rbx, %rdi
callq 0x23fe
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x2e56
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1358(%rip), %rsi      # 0x41be
leaq 0x135a(%rip), %rdx      # 0x41c7
movq %rsp, %r14
movq %r14, %rdi
callq 0x2cf6
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1f40, %edx           # imm = 0x1F40
movl $0x5, %ecx
callq 0x24c0
movl %eax, %ebx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2ea5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21c0
testb %bl, %bl
je 0x2ef7
movq 0x3140(%rip), %rbx      # 0x5ff0
leaq 0x1329(%rip), %rsi      # 0x41e0
movl $0x1e, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2110
movl $0x1, %edi
callq 0x2130
jmp 0x2eeb
movq 0x30f2(%rip), %rbx      # 0x5ff0
leaq 0x12c3(%rip), %rsi      # 0x41c8
movl $0x17, %edx
movq %rbx, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2110
movl $0x1, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2f91
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2f89
movq 0x10(%rsp), %rsi
incq %rsi
jmp 0x2f84
movq %rax, %r14
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x2f7c
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl $0x68, %esi
movq %rbx, %rdi
callq 0x21c0
movq %r14, %rdi
callq 0x2230
movq %rax, %rdi
callq 0x2b1f
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
testq %rdi, %rdi
je 0x13ef
movq 0xecb4(%rip), %rax      # 0x100a0
movq %rax, (%rdi)
testq %rsi, %rsi
je 0x13fe
movq 0xecad(%rip), %rax      # 0x100a8
movq %rax, (%rsi)
testq %rdx, %rdx
je 0x140d
movq 0xeca6(%rip), %rax      # 0x100b0
movq %rax, (%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
testq %rdi, %rdi
leaq 0x37(%rip), %rax        # 0x1454
cmovneq %rdi, %rax
testq %rsi, %rsi
leaq 0x62(%rip), %rcx        # 0x148d
cmovneq %rsi, %rcx
testq %rdx, %rdx
leaq 0x6c(%rip), %rsi        # 0x14a5
cmovneq %rdx, %rsi
movq %rax, 0xec5c(%rip)      # 0x100a0
movq %rcx, 0xec5d(%rip)      # 0x100a8
movq %rsi, 0xec5e(%rip)      # 0x100b0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
testq %rdi, %rdi
je 0x1469
callq 0x10c0
testq %rax, %rax
je 0x1488
popq %rbp
retq
leaq 0x9f24(%rip), %rdi      # 0xb394
leaq 0x8bed(%rip), %rsi      # 0xa064
leaq 0x9a94(%rip), %rcx      # 0xaf12
movl $0xff, %edx
callq 0x1090
callq 0x1130
// File: /workspace/github_cpp_makefile_star2_O1/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
testq %rdx, %rdx
jle 0x1515
movq -0x8(%rdi,%rdx,8), %rcx
movq -0x8(%rsi,%rdx,8), %r8
decq %rdx
cmpq %r8, %rcx
je 0x14f1
xorl %eax, %eax
cmpq %rcx, %r8
adcl $-0x1, %eax
orl $0x1, %eax
jmp 0x1517
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
testq %rdx, %rdx
jle 0x1581
xorl %eax, %eax
addq (%rsi,%rax,8), %rcx
setb %r8b
movq %rcx, (%rdi,%rax,8)
xorl %ecx, %ecx
movb %r8b, %cl
incq %rax
cmpq %rax, %rdx
jne 0x1564
movq %rcx, %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x9c34(%rip), %rdi      # 0xb1c0
leaq 0x8ad1(%rip), %rsi      # 0xa064
leaq 0x8ae0(%rip), %rcx      # 0xa07a
movl $0x18f, %edx            # imm = 0x18F
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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
testq %rcx, %rcx
jle 0x15dc
xorl %r8d, %r8d
xorl %r9d, %r9d
movq (%rsi,%r8,8), %r10
leaq (%r9,%r10), %r11
xorl %eax, %eax
addq (%rdx,%r8,8), %r11
setb %al
addq %r10, %r9
adcq $0x0, %rax
movq %r11, (%rdi,%r8,8)
incq %r8
movq %rax, %r9
cmpq %r8, %rcx
jne 0x15b3
jmp 0x15de
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
cmpq %r8, %rdx
jl 0x1643
testq %r8, %r8
jle 0x161f
xorl %r9d, %r9d
xorl %r10d, %r10d
movq (%rsi,%r9,8), %r11
leaq (%r10,%r11), %rbx
xorl %eax, %eax
addq (%rcx,%r9,8), %rbx
setb %al
addq %r11, %r10
adcq $0x0, %rax
movq %rbx, (%rdi,%r9,8)
incq %r9
movq %rax, %r10
cmpq %r9, %r8
jne 0x15f6
jmp 0x1621
xorl %eax, %eax
subq %r8, %rdx
jle 0x163c
leaq (%rdi,%r8,8), %rdi
leaq (%rsi,%r8,8), %rsi
movq %rax, %rcx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x155d
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x8a6d(%rip), %rdi      # 0xa0b7
leaq 0x8a13(%rip), %rsi      # 0xa064
leaq 0x8a68(%rip), %rcx      # 0xa0c0
movl $0x1b5, %edx            # imm = 0x1B5
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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:
testq %rdx, %rdx
jle 0x1689
xorl %eax, %eax
movq (%rsi,%rax,8), %r8
subq %rcx, %r8
setb %r9b
xorl %ecx, %ecx
movb %r9b, %cl
movq %r8, (%rdi,%rax,8)
incq %rax
cmpq %rax, %rdx
jne 0x1669
movq %rcx, %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x9b2c(%rip), %rdi      # 0xb1c0
leaq 0x89c9(%rip), %rsi      # 0xa064
leaq 0x8a64(%rip), %rcx      # 0xa106
movl $0x1c2, %edx            # imm = 0x1C2
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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
testq %rcx, %rcx
jle 0x16e0
xorl %r8d, %r8d
xorl %r9d, %r9d
movq (%rsi,%r8,8), %r10
xorl %eax, %eax
addq (%rdx,%r8,8), %r9
setb %al
subq %r9, %r10
adcq $0x0, %rax
movq %r10, (%rdi,%r8,8)
incq %r8
movq %rax, %r9
cmpq %r8, %rcx
jne 0x16bb
jmp 0x16e2
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpq %r8, %rdx
jl 0x1731
testq %r8, %r8
jle 0x1719
xorl %r9d, %r9d
xorl %r10d, %r10d
movq (%rsi,%r9,8), %r11
xorl %eax, %eax
addq (%rcx,%r9,8), %r10
setb %al
subq %r10, %r11
adcq $0x0, %rax
movq %r11, (%rdi,%r9,8)
incq %r9
movq %rax, %r10
cmpq %r9, %r8
jne 0x16f4
jmp 0x171b
xorl %eax, %eax
subq %r8, %rdx
jle 0x1730
leaq (%rdi,%r8,8), %rdi
leaq (%rsi,%r8,8), %rsi
movq %rax, %rcx
jmp 0x1662
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x897b(%rip), %rdi      # 0xa0b7
leaq 0x8921(%rip), %rsi      # 0xa064
leaq 0x89f9(%rip), %rcx      # 0xa143
movl $0x1e9, %edx            # imm = 0x1E9
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
jle 0x17e8
movq %rcx, %r8
shrq $0x20, %r8
movl %ecx, %ecx
xorl %r9d, %r9d
movabsq $0x100000000, %r10      # imm = 0x100000000
xorl %eax, %eax
movq (%rsi,%r9,8), %rbx
movl %ebx, %r11d
shrq $0x20, %rbx
movq %r11, %r14
imulq %rcx, %r14
imulq %r8, %r11
movq %rbx, %r15
imulq %rcx, %r15
imulq %r8, %rbx
movl %r14d, %r12d
shrq $0x20, %r14
addq %r15, %r11
addq %r14, %r11
leaq (%rbx,%r10), %r14
cmpq %r15, %r11
cmovaeq %rbx, %r14
movq %r11, %rbx
shrq $0x20, %rbx
shlq $0x20, %r11
addq %rax, %r12
addq %r11, %r12
cmpq %rax, %r12
movq %rbx, %rax
adcq %r14, %rax
movq %r12, (%rdi,%r9,8)
incq %r9
cmpq %r9, %rdx
jne 0x1780
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8aa7(%rip), %rdi      # 0xa296
leaq 0x886e(%rip), %rsi      # 0xa064
leaq 0x898c(%rip), %rcx      # 0xa189
movl $0x1f6, %edx            # imm = 0x1F6
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
jle 0x18a5
movq %rcx, %r8
shrq $0x20, %r8
movl %ecx, %ecx
xorl %r9d, %r9d
movabsq $0x100000000, %r10      # imm = 0x100000000
xorl %eax, %eax
movq (%rsi,%r9,8), %rbx
movl %ebx, %r11d
shrq $0x20, %rbx
movq %r11, %r14
imulq %rcx, %r14
imulq %r8, %r11
movq %rbx, %r15
imulq %rcx, %r15
imulq %r8, %rbx
movl %r14d, %r12d
shrq $0x20, %r14
addq %r15, %r11
addq %r14, %r11
leaq (%rbx,%r10), %r14
cmpq %r15, %r11
cmovaeq %rbx, %r14
movq %r11, %rbx
shrq $0x20, %rbx
addq %r14, %rbx
shlq $0x20, %r11
addq %rax, %r12
addq %r11, %r12
xorl %r11d, %r11d
cmpq %rax, %r12
setb %r11b
addq %r12, (%rdi,%r9,8)
movq %r11, %rax
adcq %rbx, %rax
incq %r9
cmpq %r9, %rdx
jne 0x1833
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x89ea(%rip), %rdi      # 0xa296
leaq 0x87b1(%rip), %rsi      # 0xa064
leaq 0x890c(%rip), %rcx      # 0xa1c6
movl $0x20d, %edx            # imm = 0x20D
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_mul
mp_limb_t
mpn_mul (mp_ptr rp, mp_srcptr up, mp_size_t un, mp_srcptr vp, mp_size_t vn)
{
  assert (un >= vn);
  assert (vn >= 1);

  /* We first multiply by the low order limb. This result can be
     stored, not added, to rp. We also avoid a loop for zeroing this
     way. */

  rp[un] = mpn_mul_1 (rp, up, un, vp[0]);

  /* Now accumulate the product of up[] and the next higher limb from
     vp[]. */

  while (--vn >= 1)
    {
      rp += 1, vp += 1;
      rp[un] = mpn_addmul_1 (rp, up, un, vp[0]);
    }
  return rp[un];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq %r8, %rdx
jl 0x1a0e
movq %r8, %r14
testq %r8, %r8
jle 0x1a2d
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r12
movq (%rcx), %rcx
callq 0x1754
movq %rax, (%r12,%rbx,8)
cmpq $0x1, %r14
jne 0x19c3
movq %r12, %r13
jmp 0x19fa
incq %r14
addq $0x8, %r15
movq %r13, -0x30(%rbp)
leaq 0x8(%r12), %r13
movq (%r15), %rcx
movq %r13, %rdi
movq -0x30(%rbp), %rsi
movq %rbx, %rdx
callq 0x1807
movq %rax, 0x8(%r12,%rbx,8)
decq %r14
addq $0x8, %r15
movq %r13, %r12
cmpq $0x2, %r14
jg 0x19ce
movq (%r13,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8831(%rip), %rdi      # 0xa246
leaq 0x8648(%rip), %rsi      # 0xa064
leaq 0x882c(%rip), %rcx      # 0xa24f
movl $0x23f, %edx            # imm = 0x23F
callq 0x1090
leaq 0x8861(%rip), %rdi      # 0xa295
leaq 0x8629(%rip), %rsi      # 0xa064
leaq 0x880d(%rip), %rcx      # 0xa24f
movl $0x240, %edx            # imm = 0x240
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_lshift
mp_limb_t
mpn_lshift (mp_ptr rp, mp_srcptr up, mp_size_t n, unsigned int cnt)
{
  mp_limb_t high_limb, low_limb;
  unsigned int tnc;
  mp_limb_t retval;

  assert (n >= 1);
  assert (cnt >= 1);
  assert (cnt < GMP_LIMB_BITS);

  up += n;
  rp += n;

  tnc = GMP_LIMB_BITS - cnt;
  low_limb = *--up;
  retval = low_limb >> tnc;
  high_limb = (low_limb << cnt);

  while (--n != 0)
    {
      low_limb = *--up;
      *--rp = high_limb | (low_limb >> tnc);
      high_limb = (low_limb << cnt);
    }
  *--rp = high_limb;

  return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdx, %rdx
jle 0x1aec
testl %ecx, %ecx
je 0x1b0b
cmpl $0x40, %ecx
jae 0x1b2a
movl %ecx, %r8d
leaq (%rdi,%rdx,8), %r9
movl $0x40, %edi
subl %ecx, %edi
movq -0x8(%rsi,%rdx,8), %rax
movq %rax, %r11
movl %r8d, %ecx
shlq %cl, %r11
cmpq $0x1, %rdx
je 0x1ad9
movq -0x10(%rsi,%rdx,8), %r10
movq %r10, %rbx
movl %edi, %ecx
shrq %cl, %rbx
orq %r11, %rbx
movq %rbx, -0x8(%r9)
movl %r8d, %ecx
shlq %cl, %r10
addq $-0x8, %r9
decq %rdx
movq %r10, %r11
cmpq $0x1, %rdx
jne 0x1aad
jmp 0x1adc
movq %r11, %r10
movl %edi, %ecx
shrq %cl, %rax
movq %r10, -0x8(%r9)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x87a3(%rip), %rdi      # 0xa296
leaq 0x856a(%rip), %rsi      # 0xa064
leaq 0x879c(%rip), %rcx      # 0xa29d
movl $0x266, %edx            # imm = 0x266
callq 0x1090
leaq 0x87cc(%rip), %rdi      # 0xa2de
leaq 0x854b(%rip), %rsi      # 0xa064
leaq 0x877d(%rip), %rcx      # 0xa29d
movl $0x267, %edx            # imm = 0x267
callq 0x1090
leaq 0x87b6(%rip), %rdi      # 0xa2e7
leaq 0x852c(%rip), %rsi      # 0xa064
leaq 0x875e(%rip), %rcx      # 0xa29d
movl $0x268, %edx            # imm = 0x268
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_rshift
mp_limb_t
mpn_rshift (mp_ptr rp, mp_srcptr up, mp_size_t n, unsigned int cnt)
{
  mp_limb_t high_limb, low_limb;
  unsigned int tnc;
  mp_limb_t retval;

  assert (n >= 1);
  assert (cnt >= 1);
  assert (cnt < GMP_LIMB_BITS);

  tnc = GMP_LIMB_BITS - cnt;
  high_limb = *up++;
  retval = (high_limb << tnc);
  low_limb = high_limb >> cnt;

  while (--n != 0)
    {
      high_limb = *up++;
      *rp++ = low_limb | (high_limb << tnc);
      low_limb = high_limb >> cnt;
    }
  *rp = low_limb;

  return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
jle 0x1bcc
testl %ecx, %ecx
je 0x1beb
cmpl $0x40, %ecx
jae 0x1c0a
movl %ecx, %r9d
movl $0x40, %r8d
subl %ecx, %r8d
movq (%rsi), %rax
movq %rax, %r10
movl %r9d, %ecx
shrq %cl, %r10
decq %rdx
je 0x1bb8
xorl %r11d, %r11d
xorl %ebx, %ebx
movq 0x8(%rsi,%rbx,8), %r14
movq %r14, %r15
movl %r8d, %ecx
shlq %cl, %r15
orq %r10, %r15
movq %r14, %r10
movl %r9d, %ecx
shrq %cl, %r10
movq %r15, (%rdi,%rbx,8)
incq %rbx
addq $-0x8, %r11
cmpq %rbx, %rdx
jne 0x1b8b
subq %r11, %rdi
movl %r8d, %ecx
shlq %cl, %rax
movq %r10, (%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x86c3(%rip), %rdi      # 0xa296
leaq 0x848a(%rip), %rsi      # 0xa064
leaq 0x871a(%rip), %rcx      # 0xa2fb
movl $0x284, %edx            # imm = 0x284
callq 0x1090
leaq 0x86ec(%rip), %rdi      # 0xa2de
leaq 0x846b(%rip), %rsi      # 0xa064
leaq 0x86fb(%rip), %rcx      # 0xa2fb
movl $0x285, %edx            # imm = 0x285
callq 0x1090
leaq 0x86d6(%rip), %rdi      # 0xa2e7
leaq 0x844c(%rip), %rsi      # 0xa064
leaq 0x86dc(%rip), %rcx      # 0xa2fb
movl $0x286, %edx            # imm = 0x286
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_common_scan
static mp_bitcnt_t
mpn_common_scan (mp_limb_t limb, mp_size_t i, mp_srcptr up, mp_size_t un,
		 mp_limb_t ux)
{
  unsigned cnt;

  assert (ux == 0 || ux == GMP_LIMB_MAX);
  assert (0 <= i && i <= un );

  while (limb == 0)
    {
      i++;
      if (i == un)
	return (ux == 0 ? ~(mp_bitcnt_t) 0 : un * GMP_LIMB_BITS);
      limb = ux ^ up[i];
    }
  gmp_ctz (cnt, limb);
  return (mp_bitcnt_t) i * GMP_LIMB_BITS + cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1(%r8), %rax
cmpq $0x2, %rax
jae 0x1cdf
cmpq %rcx, %rsi
jg 0x1cfe
testq %rdi, %rdi
jne 0x1c83
leaq -0x1(%rcx), %rax
cmpq %rsi, %rax
je 0x1ccd
movq 0x8(%rdx,%rsi,8), %rdi
incq %rsi
cmpq %r8, %rdi
je 0x1c6e
xorq %r8, %rdi
movq %rdi, %rdx
negq %rdx
andq %rdi, %rdx
xorl %ecx, %ecx
movq %rdx, %rax
shrq $0x38, %rax
jne 0x1cae
xorl %ecx, %ecx
movq %rdx, %rax
shlq $0x8, %rax
addl $0x8, %ecx
shrq $0x30, %rdx
movq %rax, %rdx
je 0x1c9c
jmp 0x1cb8
movq %rdx, %rax
jmp 0x1cb8
addq %rax, %rax
incl %ecx
testq %rax, %rax
jns 0x1cb3
movl $0x3f, %eax
subl %ecx, %eax
shlq $0x6, %rsi
addq %rsi, %rax
popq %rbp
retq
shlq $0x6, %rcx
xorl %eax, %eax
cmpq $0x1, %r8
sbbq %rax, %rax
orq %rcx, %rax
jmp 0x1ccb
leaq 0x92a8(%rip), %rdi      # 0xaf8e
leaq 0x8377(%rip), %rsi      # 0xa064
leaq 0x92b8(%rip), %rcx      # 0xafac
movl $0x29e, %edx            # imm = 0x29E
callq 0x1090
leaq 0x92fa(%rip), %rdi      # 0xafff
leaq 0x8358(%rip), %rsi      # 0xa064
leaq 0x9299(%rip), %rcx      # 0xafac
movl $0x29f, %edx            # imm = 0x29F
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_get_str
size_t
mpn_get_str (unsigned char *sp, int base, mp_ptr up, mp_size_t un)
{
  unsigned bits;

  assert (un > 0);
  assert (up[un-1] > 0);

  bits = mpn_base_power_of_two_p (base);
  if (bits)
    return mpn_get_str_bits (sp, bits, up, un);
  else
    {
      struct mpn_base_info info;

      mpn_get_base_info (&info, base);
      return mpn_get_str_other (sp, base, &info, up, un);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rcx, %rcx
jle 0x1f72
movq %rcx, %rbx
movq %rdx, %r14
cmpq $0x0, -0x8(%rdx,%rcx,8)
je 0x1f91
movl %esi, %r12d
movq %rdi, %r15
movl %esi, %edi
callq 0x1fb0
testl %eax, %eax
je 0x1f27
movq %r15, %rdi
movl %eax, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x202b
movslq %r12d, %rcx
movl $0x1, %esi
testl %r12d, %r12d
js 0x1f47
movq %rcx, %rdi
imulq %rcx, %rdi
incl %esi
movq %rcx, %rax
mulq %rdi
jno 0x1f37
jmp 0x1f4a
movq %rcx, %rdi
leaq -0x30(%rbp), %rdx
movl %esi, (%rdx)
movq %rdi, 0x8(%rdx)
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rcx
movq %rbx, %r8
callq 0x20d8
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x840a(%rip), %rdi      # 0xa383
leaq 0x80e4(%rip), %rsi      # 0xa064
leaq 0x8403(%rip), %rcx      # 0xa38a
movl $0x4e9, %edx            # imm = 0x4E9
callq 0x1090
leaq 0x842e(%rip), %rdi      # 0xa3c6
leaq 0x80c5(%rip), %rsi      # 0xa064
leaq 0x83e4(%rip), %rcx      # 0xa38a
movl $0x4ea, %edx            # imm = 0x4EA
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_base_power_of_two_p
static unsigned
mpn_base_power_of_two_p (unsigned b)
{
  switch (b)
    {
    case 2: return 1;
    case 4: return 2;
    case 8: return 3;
    case 16: return 4;
    case 32: return 5;
    case 64: return 6;
    case 128: return 7;
    case 256: return 8;
    default: return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x1f, %edi
jg 0x1fd4
cmpl $0x7, %edi
jg 0x1fea
movl $0x1, %eax
cmpl $0x2, %edi
je 0x2029
cmpl $0x4, %edi
jne 0x2027
movl $0x2, %eax
jmp 0x2029
cmpl $0x7f, %edi
jg 0x1ffb
cmpl $0x20, %edi
je 0x2012
cmpl $0x40, %edi
jne 0x2027
movl $0x6, %eax
jmp 0x2029
cmpl $0x8, %edi
je 0x2019
cmpl $0x10, %edi
jne 0x2027
movl $0x4, %eax
jmp 0x2029
cmpl $0x80, %edi
je 0x2020
cmpl $0x100, %edi            # imm = 0x100
jne 0x2027
movl $0x8, %eax
jmp 0x2029
movl $0x5, %eax
jmp 0x2029
movl $0x3, %eax
jmp 0x2029
movl $0x7, %eax
jmp 0x2029
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/marxn[P]pupp/3rdparty/gmp/./mini-gmp/mini-gmp.c
// Function: mpn_get_str_bits
static size_t
mpn_get_str_bits (unsigned char *sp, unsigned bits, mp_srcptr up, mp_size_t un)
{
  unsigned char mask;
  size_t sn, j;
  mp_size_t i;
  int shift;

  sn = ((un - 1) * GMP_LIMB_BITS + mpn_limb_size_in_base_2 (up[un-1])
	+ bits - 1) / bits;

  mask = (1U << bits) - 1;

  for (i = 0, j = sn, shift = 0; j-- > 0;)
    {
      unsigned char digit = up[i] >> shift;

      shift += bits;

      if (shift >= GMP_LIMB_BITS && ++i < un)
	{
	  shift -= GMP_LIMB_BITS;
	  digit |= up[i] << (bits - shift);
	}
      sp[j] = digit & mask;
    }
  return sn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
leaq -0x1(%rcx), %r13
shlq $0x6, %r13
movq -0x8(%rdx,%rcx,8), %rdi
callq 0x7a30
movl %r15d, %edi
addq %rdi, %r13
leaq (%rax,%r13), %rcx
decq %rcx
xorl %esi, %esi
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
cmpq %rdi, %rcx
jb 0x20c9
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %r15d, %ecx
shll %cl, %edx
notl %edx
movq %rax, %rdi
xorl %r10d, %r10d
movq (%r14,%r10,8), %r8
movl %esi, %ecx
shrq %cl, %r8
addl %r15d, %esi
cmpl $0x40, %esi
jb 0x20b4
leaq 0x1(%r10), %r9
cmpq %rbx, %r9
jge 0x20b7
addl $-0x40, %esi
movq 0x8(%r14,%r10,8), %r10
movl %r15d, %ecx
subl %esi, %ecx
shlq %cl, %r10
orq %r10, %r8
jmp 0x20b7
movq %r10, %r9
decq %rdi
andl %edx, %r8d
movb %r8b, (%r12,%rdi)
movq %r9, %r10
testq %rdi, %rdi
jne 0x2085
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq