LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/shuhaosun[P]Splitter-Windowed-CountMin/./Splitter.h
// Function: Splitter::Expire(Node*, int, int, int)
void Expire(DLNode *head, int t, int i, int j)
	{
		DLNode *p, *q;
		double ratio;
		double scale;

		p = head->next;

		while(p != head && ((p->init < t - WINDOW_SIZE) || (p->init == t - WINDOW_SIZE)))
		{
			if (p->last > t - WINDOW_SIZE)//the second node is totally in the window
			{
				ratio = (t - WINDOW_SIZE) - p->init + 1;
				scale = p->count / (p->last - p->init + 1);
				counter[i][j] = counter[i][j] - ratio*scale;

				p->count = p->count - ratio*scale;
				p->init = p->init + ratio;
				p = p->next;
			}
			else
			{
				counter[i][j] = counter[i][j] - p->count;

				//delete p node
				q = p;
				p = p->next;
			    q->prior->next = q->next;
				q->next->prior = q->prior;
				free(q);
				if (p == head)
				{
					counter[i][j] = 0;
				}
				memoryusage = memoryusage - 2*12 - 16;
			}
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x18(%rsi), %rdi
cmpq %rsi, %rdi
je 0x1fd9
movq %rsi, %rbx
cvtsi2sd %edx, %xmm4
addsd 0x1166(%rip), %xmm4     # 0x3058
movslq %ecx, %r15
movslq %r8d, %r12
movsd %xmm4, 0x8(%rsp)
movsd (%rdi), %xmm0
ucomisd %xmm0, %xmm4
jb 0x1fd9
movsd 0x8(%rdi), %xmm1
ucomisd %xmm4, %xmm1
jbe 0x1f7c
movapd %xmm4, %xmm2
subsd %xmm0, %xmm2
movsd 0x1139(%rip), %xmm5     # 0x3060
addsd %xmm5, %xmm2
movsd 0x10(%rdi), %xmm3
subsd %xmm0, %xmm1
addsd %xmm5, %xmm1
divsd %xmm1, %xmm3
movq 0xf0(%r14,%r15,8), %rax
movapd %xmm2, %xmm0
xorpd 0x1160(%rip), %xmm0     # 0x30b0
mulsd %xmm3, %xmm0
movsd (%rax,%r12,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rax,%r12,8)
addsd 0x10(%rdi), %xmm0
movsd %xmm0, 0x10(%rdi)
addsd (%rdi), %xmm2
movsd %xmm2, (%rdi)
movq 0x18(%rdi), %r13
jmp 0x1fcd
movq 0xf0(%r14,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
subsd 0x10(%rdi), %xmm0
movsd %xmm0, (%rax,%r12,8)
movq 0x18(%rdi), %r13
movq 0x20(%rdi), %rax
movq %r13, 0x18(%rax)
movq %rax, 0x20(%r13)
callq 0x1150
cmpq %rbx, %r13
jne 0x1fbf
movq 0xf0(%r14,%r15,8), %rax
movq $0x0, (%rax,%r12,8)
addl $-0x28, 0x7a13ac(%r14)
movsd 0x8(%rsp), %xmm4
movq %r13, %rdi
cmpq %rbx, %r13
jne 0x1efe
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/shuhaosun[P]Splitter-Windowed-CountMin/./Splitter.h
// Function: Splitter::Error(Node*, Node*)
double Error(DLNode *p, DLNode *l)
	{
		double error;
		double Fprev = p->count / (l->init - p->init);
		double Fnow = l->count / (l->last - l->init + 1);
		if (Fprev > Fnow) 
			error = Fprev / Fnow;
		else 
			error = Fnow / Fprev;

		if (error == 0)
		{
			printf("error = : %f\n", error);
		}
		return error;
	}

// Assembly:
movsd (%rdx), %xmm0
movsd 0x8(%rdx), %xmm1
subsd %xmm0, %xmm1
subsd (%rsi), %xmm0
addsd 0x105f(%rip), %xmm1     # 0x3060
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
movsd 0x10(%rsi), %xmm1
movhpd 0x10(%rdx), %xmm1       # xmm1 = xmm1[0],mem[0]
divpd %xmm0, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
movapd %xmm1, %xmm3
divsd %xmm0, %xmm3
movapd %xmm0, %xmm2
divsd %xmm1, %xmm2
cmpltsd %xmm1, %xmm0
andpd %xmm0, %xmm3
andnpd %xmm2, %xmm0
orpd %xmm3, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x2068
jp 0x2068
subq $0x18, %rsp
leaq 0x113a(%rip), %rdi      # 0x318d
movb $0x1, %al
movapd %xmm0, (%rsp)
callq 0x1040
movapd (%rsp), %xmm0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ChanTsune[P]py_string/./py_string.hpp
// Function: py::basic_string<char>::operator*(unsigned long) const
basic_string<_Elme> basic_string<_Elme>::operator*(size_t i) const
{
  if (i <= 0)
    return "";
  basic_string<_Elme> str(*this);
  str.reserve(str.size() * i);
  for (; --i;) {
    str += *this;
  }
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
testq %rdx, %rdx
je 0x59f8
movq %rdx, %r14
movq %rsi, %r15
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x6874
movq 0x8(%rbx), %rsi
imulq %r14, %rsi
movq %rbx, %rdi
callq 0x4470
decq %r14
je 0x5a0a
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x40c0
jmp 0x59e2
leaq 0x16878(%rip), %rdx     # 0x1c277
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x641a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5a18
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x5a2f
movq (%r12), %rsi
incq %rsi
callq 0x42d0
movq %r14, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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>, py::null_allow::null_allow<int>) const
basic_string<_Elme> basic_string<_Elme>::slice(optional_int start,
                                               optional_int end,
                                               optional_int step) const
{
  if (step == 0)
    return "";
  if (!step.has_value() || step == 1)
    return this->slice(start, end);

  int start_i, step_i, len_i;
  basic_string<_Elme> str = "";
  std::tie(start_i, std::ignore, step_i, len_i)
    = util::adjust_index<int>(start, end, step, this->size());

  for (int i = 0; i < len_i; i += 1) {
    str.push_back(this->at(start_i));
    start_i += step_i;
  }
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rdi, %rbx
testl %r15d, %r15d
je 0x5adf
movq %rdx, %r13
movq %rsi, %r14
movq %r15, %rax
shrq $0x20, %rax
andl $0x1, %eax
cmpl $0x1, %r15d
setne %dl
testb %al, %dl
je 0x5afd
movq %rcx, -0x38(%rbp)
leaq 0x10(%rbx), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rbx)
leaq 0x167ea(%rip), %rdx     # 0x1c277
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x641a
movl 0x8(%r14), %ecx
xorl %r12d, %r12d
movl %ecx, %eax
movl $0x0, %edx
movl %ecx, %esi
testl %r15d, %r15d
jns 0x5abe
leal -0x1(%rcx), %r12d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %r12d, %esi
movabsq $0x100000000, %r8       # imm = 0x100000000
testq %r8, %r13
movq -0x38(%rbp), %rdi
je 0x5b1a
testl %r13d, %r13d
js 0x5b0d
cmpl %r13d, %esi
cmovll %esi, %r13d
jmp 0x5b17
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1678a(%rip), %rdx     # 0x1c277
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x641a
jmp 0x5b86
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x124be
jmp 0x5b86
addl %ecx, %r13d
cmpl %edx, %r13d
cmovlel %edx, %r13d
movl %r13d, %r12d
testq %r8, %rdi
je 0x5b35
testl %edi, %edi
js 0x5b2c
cmpl %edi, %esi
cmovll %esi, %edi
movl %edi, %eax
jmp 0x5b35
addl %edi, %ecx
cmpl %edx, %ecx
cmovlel %edx, %ecx
movl %ecx, %eax
testl %r15d, %r15d
js 0x5b4c
cmpl %eax, %r12d
jge 0x5b86
movl %r12d, %ecx
notl %ecx
addl %ecx, %eax
cltd
idivl %r15d
jmp 0x5b5e
cmpl %r12d, %eax
jge 0x5b86
notl %eax
addl %r12d, %eax
movl %r15d, %ecx
negl %ecx
cltd
idivl %ecx
movl %eax, %r13d
testl %eax, %eax
js 0x5b86
incl %r13d
movq %r14, %rdi
movl %r12d, %esi
callq 0x1252e
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0x4280
addl %r15d, %r12d
decl %r13d
jne 0x5b68
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x5bb3
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x42d0
movq %r14, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O3/ChanTsune[P]py_string/./py_string.hpp
// Function: py::basic_string<char>::operator[](std::initializer_list<py::null_allow::null_allow<int>>)
basic_string<_Elme>
basic_string<_Elme>::operator[](std::initializer_list<optional_int> slice)
{
  basic_string<_Elme> str;
  auto in = slice.begin();
  optional_int index1 = *in++;
  optional_int index2 = *in++;
  optional_int index3 = *in;

  switch (slice.size()) {
  case 0:
    return *this;
  case 1:
    return this->slice(index1);
  case 2:
    return this->slice(index1, index2);
  default: // case 3:
    return this->slice(index1, index2, index3);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r8
movq %rdx, %rax
movq %rdi, %rbx
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq (%rdx), %rdx
movq 0x8(%rax), %rcx
cmpq $0x2, %r8
je 0x5c24
cmpq $0x1, %r8
je 0x5c1a
testq %r8, %r8
jne 0x5c2e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6874
jmp 0x5c3a
movq %rbx, %rdi
callq 0x12588
jmp 0x5c3a
movq %rbx, %rdi
callq 0x124be
jmp 0x5c3a
movq 0x10(%rax), %r8
movq %rbx, %rdi
callq 0x5a38
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x5c4f
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x5c73
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O3/ChanTsune[P]py_string/./py_string.hpp
// Function: py::basic_string<char> py::basic_string<char>::format<int, char const*, int>(int, char const*, int)
basic_string<_Elme> basic_string<_Elme>::format(Args... args)
{
  basic_string<_Elme> str(*this);
  static std::regex match("\\{(![^:])?(:(.+?)?)?\\}");
  if (std::regex_search(str, match)) {
    return this->_format_automatic(str, std::move(args)...);
  }
  return this->_format<0>(str, std::move(args)...);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r8d, -0x2c(%rbp)
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %rbx
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%rsi), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x6874
movb 0x1faaa(%rip), %al      # 0x25768
testb %al, %al
je 0x5d6a
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
leaq 0x1fa62(%rip), %rcx     # 0x25748
xorl %r8d, %r8d
callq 0x12f94
movl %eax, %r14d
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x5d06
movq -0x60(%rbp), %rsi
subq %rdi, %rsi
callq 0x42d0
testb %r14b, %r14b
je 0x5d26
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %ecx
movq %r15, %r8
movl -0x2c(%rbp), %r9d
callq 0x125e2
jmp 0x5d3f
leaq -0x50(%rbp), %rdx
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %ecx
movq %r15, %r8
movl -0x2c(%rbp), %r9d
callq 0x12950
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5d58
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f9f7(%rip), %rdi     # 0x25768
callq 0x4530
testl %eax, %eax
je 0x5cc6
leaq 0x1f9c3(%rip), %rdi     # 0x25748
leaq 0x16d9d(%rip), %rsi     # 0x1cb29
movl $0x10, %edx
callq 0x590a
leaq -0x427(%rip), %rdi      # 0x5976
leaq 0x1f9a4(%rip), %rsi     # 0x25748
leaq 0x1f51d(%rip), %rdx     # 0x252c8
callq 0x4290
leaq 0x1f9b1(%rip), %rdi     # 0x25768
callq 0x41f0
jmp 0x5cc6
movq %rax, %rbx
leaq 0x1f99d(%rip), %rdi     # 0x25768
callq 0x41e0
jmp 0x5def
movq %rax, %rbx
jmp 0x5def
movq %rax, %rbx
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x5def
movq -0x60(%rbp), %rsi
subq %rdi, %rsi
callq 0x42d0
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5e08
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O3/ChanTsune[P]py_string/./py_string.hpp
// Function: py::basic_string<char>::pyreplace(py::basic_string<char>, py::basic_string<char>, unsigned long) const
basic_string<_Elme> basic_string<_Elme>::pyreplace(basic_string<_Elme> old,
                                                   basic_string<_Elme> _new,
                                                   size_t count) const
{
  size_t cursor = 0;
  basic_string<_Elme> s(*this);
  size_t oldlen = old.size(), newlen = _new.size();
  cursor = s.find(old, cursor);
  while (cursor != std::basic_string<_Elme>::npos && cursor <= s.size()
         && count > 0) {
    s.replace(cursor, oldlen, _new);
    cursor += newlen;
    if (oldlen != 0) {
      cursor = s.find(old, cursor);
    } else {
      ++cursor;
    }
    --count;
  }
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x6874
movq (%r12), %rsi
movq %r12, -0x38(%rbp)
movq 0x8(%r12), %r13
movq 0x8(%r15), %rax
movq %rax, -0x40(%rbp)
movq %rbx, %rdi
xorl %edx, %edx
movq %r13, %rcx
callq 0x4500
cmpq $-0x1, %rax
je 0x6052
movq %rax, %r12
addq $-0x1, %r14
setb %al
cmpq 0x8(%rbx), %r12
ja 0x6052
testb %al, %al
je 0x6052
movq (%r15), %rcx
movq 0x8(%r15), %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x4330
addq -0x40(%rbp), %r12
testq %r13, %r13
je 0x6049
movq -0x38(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rcx
movq %rbx, %rdi
movq %r12, %rdx
callq 0x4500
movq %rax, %r12
jmp 0x604c
incq %r12
cmpq $-0x1, %r12
jne 0x5fff
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x607f
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x42d0
movq %r14, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, -0x40(%rbp)
movq 0x8(%rdx), %rax
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0x6182
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 0x6106
movq %rbx, %rdi
callq 0x1a96e
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq %rbx, -0x30(%rbp)
testq %r15, %r15
je 0x619e
xorl %ebx, %ebx
movq -0x40(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4500
cmpq $-0x1, %rax
je 0x61a3
movq %rax, %r13
movq %rax, %rcx
subq %rbx, %rcx
movq %r14, %rsi
leaq -0x60(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rdx
callq 0x12564
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x1ad3a
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x6171
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x42d0
decq %r15
addq -0x38(%rbp), %r13
movq %r13, %rbx
testq %r15, %r15
jne 0x6115
jmp 0x61a6
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 0x1a73e
xorl %r13d, %r13d
jmp 0x61a6
movq %rbx, %r13
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq $-0x1, %rcx
callq 0x12564
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x1ad3a
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x61e4
movq -0x50(%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 -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
jmp 0x620b
movq %rax, %rbx
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x621c
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O3/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 0x62c2
jge 0x6287
movq 0x8(%r15), %rdx
movq 0x8(%r12), %rcx
jmp 0x628b
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 0x1ae9c
movq 0x8(%rax), %rdx
movsbl %r14b, %r8d
movl $0x1, %ecx
movq %rax, %rdi
xorl %esi, %esi
callq 0x4540
movq %r13, %rax
jmp 0x6274
movq -0x30(%rbp), %rax
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x6300
movq (%rax), %r14
leaq 0x15f9e(%rip), %r15     # 0x1c277
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ae9c
movq 0x8(%rax), %rdx
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rcx
xorl %r8d, %r8d
callq 0x4460
incq %r14
decq %r12
jne 0x62d9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6314
movq %rax, %r14
movq %rbx, %rdi
callq 0x6946
movq %r14, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x639b
movq %rdx, %r14
movq (%rsi), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1b2e2
testq %rax, %rax
je 0x6387
movq %r14, %rdi
movq %r15, %rsi
callq 0x1ae9c
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x40c0
jmp 0x6393
movsbl (%r15), %esi
movq %rbx, %rdi
callq 0x4280
incq %r15
decq %r13
jne 0x635b
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 0x63c4
movq (%r12), %rsi
incq %rsi
callq 0x42d0
movq %r14, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O3/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 0x124f3
testl %edx, %edx
js 0x124ea
cmpl %edx, %eax
cmovll %eax, %edx
movl %edx, %edi
jmp 0x124f3
addl %eax, %edx
xorl %edi, %edi
testl %edx, %edx
cmovgl %edx, %edi
testq %r8, %rcx
je 0x1250e
testl %ecx, %ecx
js 0x12505
cmpl %ecx, %eax
cmovll %eax, %ecx
movl %ecx, %eax
jmp 0x1250e
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 0x12564
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x162bc
leal -0x1(%rax), %r13d
btl %eax, %r14d
movl $0x0, %esi
adcl $0x30, %esi
movq %r15, %rdi
callq 0x4280
movl %r13d, %eax
jmp 0x1629a
leaq -0x48(%rbp), %rdi
movl $0x31, %esi
xorl %edx, %edx
callq 0x43d0
cmpq $-0x1, %rax
je 0x162ea
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x4300
jmp 0x16307
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x6867(%rip), %rsi      # 0x1cb5f
leaq 0x6861(%rip), %rdx      # 0x1cb60
movq %rbx, %rdi
callq 0x641a
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x1631c
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 0x16332
jmp 0x16332
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x1634a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O3/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, -0x50(%rbp)
movq %rdi, %r13
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x163f9
movq %rdx, %r15
movq %r13, -0x58(%rbp)
movq (%r13), %rax
leaq (%r14,%rax), %rbx
decq %rbx
negq %r14
movl $0x1, %r12d
leaq -0x48(%rbp), %r13
movsbl (%rbx), %esi
movq %r13, %rdi
callq 0x4280
movq %r12, %rax
xorl %edx, %edx
divq %r15
testq %rdx, %rdx
jne 0x163d4
movq -0x50(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r13, %rdi
callq 0x40c0
leaq (%r14,%r12), %rax
incq %rax
incq %r12
decq %rbx
cmpq $0x1, %rax
jne 0x163a9
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
leaq -0x38(%rbp), %r12
movq -0x58(%rbp), %r13
jmp 0x163fe
xorl %eax, %eax
movq %r12, %rcx
movb -0x1(%rcx,%rax), %al
movq -0x50(%rbp), %rdx
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
cmpb -0x1(%rcx,%rdx), %al
jne 0x1641c
leaq -0x48(%rbp), %rdi
callq 0x4390
movq $0x0, 0x8(%r13)
movq (%r13), %rax
movb $0x0, (%rax)
movq -0x48(%rbp), %r14
movq -0x40(%rbp), %rbx
testq %rbx, %rbx
je 0x1644f
movsbl -0x1(%r14,%rbx), %esi
movq %r13, %rdi
callq 0x4280
decq %rbx
jne 0x16438
movq -0x48(%rbp), %r14
cmpq %r12, %r14
je 0x16463
movq -0x38(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x42d0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16474
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x16490
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O3/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 0x58ce(%rip), %r15      # 0x1cb6a
movq %rsi, %rdi
movq %r15, %rsi
callq 0x40b0
testl %eax, %eax
je 0x172e3
leaq 0x58ba(%rip), %r15      # 0x1cb6c
movq %r12, %rdi
movq %r15, %rsi
callq 0x40b0
testl %eax, %eax
je 0x172e3
leaq 0x4ee7(%rip), %rax      # 0x1c1af
leaq 0x4fa8(%rip), %rcx      # 0x1c277
testb %r14b, %r14b
cmovneq %rax, %rcx
movzbl %r14b, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
jmp 0x17301
leaq 0x4ec5(%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_O3/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 0x1792e
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 0x6874
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 0x17949
movq %rax, -0x88(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0x17951
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r13), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x6874
jmp 0x17a01
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 0x17de0
movq -0xa8(%rbp), %rdi
cmpq %r13, %rdi
je 0x179b7
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x42d0
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x179cf
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x42d0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x179e8
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x42d0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x17a01
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 0x17a39
movq -0x98(%rbp), %rsi
incq %rsi
callq 0x42d0
jmp 0x17a39
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r12, %rdi
je 0x17a56
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x42d0
jmp 0x17a56
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x17a74
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x42d0
jmp 0x17a74
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x17a8d
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
cmpq $0x0, 0x8(%rsi)
je 0x1a9f1
movq (%rsi), %rax
xorl %edx, %edx
movabsq $0x1f0003e00, %rcx      # imm = 0x1F0003E00
movzbl (%rax,%rdx), %edi
cmpq $0x20, %rdi
ja 0x1a9e0
btq %rdi, %rcx
jae 0x1a9e0
incq %rdx
jmp 0x1a9cb
movq %rbx, %rdi
movq $-0x1, %rcx
callq 0x12564
jmp 0x1aa06
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rsi), %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x6874
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1b2c6
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x1ae9c
leaq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x41a0
jmp 0x1b2a4
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x6946
movq %r14, %rdi
callq 0x4510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x1, %esi
callq 0x21c0
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x2486
cmpq $0x0, (%rdi)
jne 0x24ac
movl $0x8, %esi
callq 0x21c0
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x24aa
addq $0x38, %rbx
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
popq %rbx
retq
callq 0x2070
jmp 0x24b3
movq %rax, %rdi
callq 0x2b04
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x25af
movl $0x1, (%rbx)
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movq %rbx, %rcx
movl $0x4, %r8d
callq 0x2240
leaq 0x8(%rbx), %rsi
movq $0x0, 0x10(%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 0x25b8
movl 0x4(%rbx), %edi
movl %ebp, %esi
callq 0x21d0
testl %eax, %eax
js 0x25c1
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 0x37a1(%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 0x25a0
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, 0x60(%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1a4e(%rip), %rdi      # 0x4004
jmp 0x25c8
leaq 0x1a5c(%rip), %rdi      # 0x401b
jmp 0x25c8
leaq 0x1a63(%rip), %rdi      # 0x402b
callq 0x2160
xorl %eax, %eax
jmp 0x25a6
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x25e9
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x25e9
movq %rax, %rbx
movl $0x8, %esi
movq %r14, %rdi
callq 0x21c0
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movl $0x10, 0x30(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x58(%rdi), %rax
movb (%rax), %al
testb $0x1, %al
je 0x26fd
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
leaq 0x18(%rdi), %r15
leaq 0x18(%rsp), %r13
movl 0x4(%rbx), %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2080
movl %eax, %r12d
testl %eax, %eax
js 0x26ef
movl $0x8, %edi
callq 0x21b0
movq %rax, %rbp
movq $0x0, (%rax)
movl $0x18, %edi
callq 0x21b0
leaq 0x36cf(%rip), %rcx      # 0x5d58
movq %rcx, (%rax)
movl %r12d, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rax, 0x18(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x2180
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x26b6
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbp, 0x20(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x26d2
movq %rbp, (%rsi)
addq $0x8, 0x8(%rsp)
jmp 0x26df
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x2ba6
movq 0x58(%rbx), %rax
movb (%rax), %al
testb $0x1, %al
jne 0x264b
jmp 0x26fd
leaq 0x1947(%rip), %rdi      # 0x403d
callq 0x2160
jmp 0x26df
movq (%rsp), %rbx
movq 0x8(%rsp), %r14
cmpq %r14, %rbx
je 0x2730
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2719
cmpq $0x0, (%rdi)
jne 0x2756
movl $0x8, %esi
callq 0x21c0
addq $0x8, %rbx
cmpq %r14, %rbx
jne 0x270b
movq (%rsp), %rbx
testq %rbx, %rbx
je 0x2745
movq 0x10(%rsp), %rsi
subq %rbx, %rsi
movq %rbx, %rdi
callq 0x21c0
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2070
movq %rax, %rbx
jmp 0x2773
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2773
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x8, %esi
movq %rbp, %rdi
callq 0x21c0
jmp 0x2787
jmp 0x2784
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x279d
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x20(%rsp), %rsi
movq $0x0, 0x8(%rsi)
leaq -0x8d(%rip), %rax       # 0x2d78
movq %rax, (%rsi)
leaq 0x179(%rip), %rax       # 0x2f88
movq %rax, 0x18(%rsi)
leaq 0x17c(%rip), %rax       # 0x2f96
movq %rax, 0x10(%rsi)
movl $0x186a0, %edx          # imm = 0x186A0
movq %rbx, %rdi
callq 0x23fe
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x2e44
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x136a(%rip), %rsi      # 0x41be
leaq 0x136c(%rip), %rdx      # 0x41c7
movq %rsp, %r14
movq %r14, %rdi
callq 0x2ce2
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1f40, %edx           # imm = 0x1F40
movl $0x5, %ecx
callq 0x24bc
movl %eax, %ebx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2e93
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21c0
testb %bl, %bl
je 0x2ee5
movq 0x3152(%rip), %rbx      # 0x5ff0
leaq 0x133b(%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 0x2ed9
movq 0x3104(%rip), %rbx      # 0x5ff0
leaq 0x12d5(%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 0x2f7f
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2f77
movq 0x10(%rsp), %rsi
incq %rsi
jmp 0x2f72
movq %rax, %r14
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x2f6a
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 0x2b04
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19fc
movq %r8, %rbx
testq %r8, %r8
jle 0x1a1b
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq (%rcx), %rcx
callq 0x1754
movq %rax, (%r13,%r15,8)
cmpq $0x1, %rbx
je 0x19ed
incq %rbx
addq $0x8, %r14
addq $0x8, %r13
movq (%r14), %rcx
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1807
movq %rax, (%r13,%r15,8)
decq %rbx
addq $0x8, %r14
addq $0x8, %r13
cmpq $0x2, %rbx
ja 0x19c6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8843(%rip), %rdi      # 0xa246
leaq 0x865a(%rip), %rsi      # 0xa064
leaq 0x883e(%rip), %rcx      # 0xa24f
movl $0x23f, %edx            # imm = 0x23F
callq 0x1090
leaq 0x8873(%rip), %rdi      # 0xa295
leaq 0x863b(%rip), %rsi      # 0xa064
leaq 0x881f(%rip), %rcx      # 0xa24f
movl $0x240, %edx            # imm = 0x240
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ada
testl %ecx, %ecx
je 0x1af9
cmpl $0x40, %ecx
jae 0x1b18
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 0x1ac7
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 0x1a9b
jmp 0x1aca
movq %r11, %r10
movl %edi, %ecx
shrq %cl, %rax
movq %r10, -0x8(%r9)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x87b5(%rip), %rdi      # 0xa296
leaq 0x857c(%rip), %rsi      # 0xa064
leaq 0x87ae(%rip), %rcx      # 0xa29d
movl $0x266, %edx            # imm = 0x266
callq 0x1090
leaq 0x87de(%rip), %rdi      # 0xa2de
leaq 0x855d(%rip), %rsi      # 0xa064
leaq 0x878f(%rip), %rcx      # 0xa29d
movl $0x267, %edx            # imm = 0x267
callq 0x1090
leaq 0x87c8(%rip), %rdi      # 0xa2e7
leaq 0x853e(%rip), %rsi      # 0xa064
leaq 0x8770(%rip), %rcx      # 0xa29d
movl $0x268, %edx            # imm = 0x268
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1bba
testl %ecx, %ecx
je 0x1bd9
cmpl $0x40, %ecx
jae 0x1bf8
movl %ecx, %r9d
movl $0x40, %r8d
subl %ecx, %r8d
movq (%rsi), %rax
movq %rax, %r10
movl %r9d, %ecx
shrq %cl, %r10
decq %rdx
je 0x1ba6
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 0x1b79
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 0x86d5(%rip), %rdi      # 0xa296
leaq 0x849c(%rip), %rsi      # 0xa064
leaq 0x872c(%rip), %rcx      # 0xa2fb
movl $0x284, %edx            # imm = 0x284
callq 0x1090
leaq 0x86fe(%rip), %rdi      # 0xa2de
leaq 0x847d(%rip), %rsi      # 0xa064
leaq 0x870d(%rip), %rcx      # 0xa2fb
movl $0x285, %edx            # imm = 0x285
callq 0x1090
leaq 0x86e8(%rip), %rdi      # 0xa2e7
leaq 0x845e(%rip), %rsi      # 0xa064
leaq 0x86ee(%rip), %rcx      # 0xa2fb
movl $0x286, %edx            # imm = 0x286
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ccd
cmpq %rcx, %rsi
jg 0x1cec
testq %rdi, %rdi
jne 0x1c71
leaq -0x1(%rcx), %rax
cmpq %rsi, %rax
je 0x1cbb
movq 0x8(%rdx,%rsi,8), %rdi
incq %rsi
cmpq %r8, %rdi
je 0x1c5c
xorq %r8, %rdi
movq %rdi, %rdx
negq %rdx
andq %rdi, %rdx
xorl %ecx, %ecx
movq %rdx, %rax
shrq $0x38, %rax
jne 0x1c9c
xorl %ecx, %ecx
movq %rdx, %rax
shlq $0x8, %rax
addl $0x8, %ecx
shrq $0x30, %rdx
movq %rax, %rdx
je 0x1c8a
jmp 0x1ca6
movq %rdx, %rax
jmp 0x1ca6
addq %rax, %rax
incl %ecx
testq %rax, %rax
jns 0x1ca1
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 0x1cb9
leaq 0x92ba(%rip), %rdi      # 0xaf8e
leaq 0x8389(%rip), %rsi      # 0xa064
leaq 0x92ca(%rip), %rcx      # 0xafac
movl $0x29e, %edx            # imm = 0x29E
callq 0x1090
leaq 0x930c(%rip), %rdi      # 0xafff
leaq 0x836a(%rip), %rsi      # 0xa064
leaq 0x92ab(%rip), %rcx      # 0xafac
movl $0x29f, %edx            # imm = 0x29F
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1f60
movq %rcx, %rbx
movq %rdx, %r14
cmpq $0x0, -0x8(%rdx,%rcx,8)
je 0x1f7f
movl %esi, %r12d
movq %rdi, %r15
movl %esi, %edi
callq 0x1f9e
testl %eax, %eax
je 0x1f15
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 0x2019
movslq %r12d, %rcx
movl $0x1, %esi
testl %r12d, %r12d
js 0x1f35
movq %rcx, %rdi
imulq %rcx, %rdi
incl %esi
movq %rcx, %rax
mulq %rdi
jno 0x1f25
jmp 0x1f38
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 0x20c6
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x841c(%rip), %rdi      # 0xa383
leaq 0x80f6(%rip), %rsi      # 0xa064
leaq 0x8415(%rip), %rcx      # 0xa38a
movl $0x4e9, %edx            # imm = 0x4E9
callq 0x1090
leaq 0x8440(%rip), %rdi      # 0xa3c6
leaq 0x80d7(%rip), %rsi      # 0xa064
leaq 0x83f6(%rip), %rcx      # 0xa38a
movl $0x4ea, %edx            # imm = 0x4EA
callq 0x1090