LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Kei18[P]pibt/./src/solver/winpibt.cpp
// Function: winPIBT::init()
void winPIBT::init() {
  G->setRegFlg(true);

  // initialize priroirty and paths
  int agentNum = A.size();
  for (int i = 0; i < agentNum; ++i) {
    epsilon.push_back((float)i / agentNum);
    eta.push_back(0);
    priority.push_back(epsilon[i] + eta[i]);
    PATHS.push_back({A[i]->getNode()});
    L.push_back(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq 0x38(%rax), %rdi
movl $0x1, %esi
callq 0x62120
movq -0x70(%rbp), %rdi
addq $0x20, %rdi
callq 0x383b0
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xad21e
movq -0x70(%rbp), %rdi
addq $0xa0, %rdi
movq %rdi, -0xa0(%rbp)
cvtsi2ssl -0x10(%rbp), %xmm0
cvtsi2ssl -0xc(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x8bac0
movq -0x70(%rbp), %rdi
addq $0xb8, %rdi
movq %rdi, -0x98(%rbp)
movl $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x536f0
movq -0xa0(%rbp), %rdi
movq -0x70(%rbp), %rax
addq $0xd0, %rax
movq %rax, -0x88(%rbp)
movslq -0x10(%rbp), %rsi
callq 0x8baf0
movq -0x98(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0x8c(%rbp)
movslq -0x10(%rbp), %rsi
callq 0x4ea00
movss -0x8c(%rbp), %xmm0
movq -0x88(%rbp), %rdi
cvtsi2ssl (%rax), %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x8bac0
movq -0x70(%rbp), %rdi
movq %rdi, %rax
addq $0x70, %rax
movq %rax, -0x80(%rbp)
addq $0x20, %rdi
movslq -0x10(%rbp), %rsi
callq 0x53720
movq (%rax), %rdi
callq 0x51cb0
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x1, -0x40(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xd730
movq -0x78(%rbp), %rcx
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xd750
jmp 0xad1a6
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd700
jmp 0xad1b5
leaq -0x38(%rbp), %rdi
callq 0xd7d0
leaq -0x51(%rbp), %rdi
callq 0xd830
movq -0x70(%rbp), %rdi
addq $0x88, %rdi
movl $0x0, -0x68(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x536f0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xad08c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xad213
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xd7d0
leaq -0x51(%rbp), %rdi
callq 0xd830
jmp 0xad227
addq $0xa0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x8880
// File: Kei18[P]pibt/./src/solver/winpibt.cpp
// Function: winPIBT::getTmax(int)
int winPIBT::getTmax(int t_tmp) {
  auto itrP = std::max_element(PATHS.begin(), PATHS.end(),
                               [] (Nodes a, Nodes b)
                               { return a.size() < b.size(); });
  int size = itrP->size() - 1;
  if (t_tmp > size) return t_tmp;
  return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x70, %rdi
callq 0x377e0
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x70, %rdi
callq 0x37500
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xaf640
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4e680
movq %rax, %rdi
callq 0x3b0e0
subq $0x1, %rax
movl %eax, -0x38(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x38(%rbp), %eax
jle 0xae6de
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xae6e4
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Kei18[P]pibt/./src/solver/winpibt.cpp
// Function: winPIBT::findPITargetAgent(Node*, int)
Agents::iterator winPIBT::findPITargetAgent(Node* v, int t) {
  auto itr = std::find_if(A.begin(), A.end(),
                          [this, v, t] (Agent* b) {
                            int id = b->getId();
                            int j = this->ell(id);
                            if (j >= t) return false;
                            if (this->lastNode(id) != v) return false;
                            return true;
                          });
  return itr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x20, %rdi
callq 0x39b60
movq -0x50(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x20, %rdi
callq 0x399f0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xaf330
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Kei18[P]pibt/./src/solver/winpibt.cpp
// Function: winPIBT::logStr[abi:cxx11]()
std::string winPIBT::logStr() {
  std::string str;
  str += "[solver] type:winPIBT-" + std::to_string(w) + "\n";
  str += "[solver] softmode:" + std::to_string(softmode) + "\n";
  str += Solver::logStr();
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x120(%rbp)
movq %rdi, %rax
movq %rax, -0x118(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x110(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x86b0
movq -0x110(%rbp), %rax
movl 0x68(%rax), %esi
leaq -0x78(%rbp), %rdi
callq 0xdf50
jmp 0xaf6cd
leaq 0x8271(%rip), %rsi      # 0xb7945
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0xdf00
jmp 0xaf6e3
leaq 0x3ecd(%rip), %rdx      # 0xb35b7
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xdeb0
jmp 0xaf6f9
movq -0x120(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8640
jmp 0xaf70b
leaq -0x38(%rbp), %rdi
callq 0x8330
leaq -0x58(%rbp), %rdi
callq 0x8330
leaq -0x78(%rbp), %rdi
callq 0x8330
movq -0x110(%rbp), %rax
movzbl 0x6c(%rax), %esi
andl $0x1, %esi
leaq -0xe8(%rbp), %rdi
callq 0xdf50
jmp 0xaf742
leaq 0x8213(%rip), %rsi      # 0xb795c
leaq -0xc8(%rbp), %rdi
leaq -0xe8(%rbp), %rdx
callq 0xdf00
jmp 0xaf75e
leaq 0x3e52(%rip), %rdx      # 0xb35b7
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0xdeb0
jmp 0xaf77a
movq -0x120(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x8640
jmp 0xaf78f
leaq -0xa8(%rbp), %rdi
callq 0x8330
leaq -0xc8(%rbp), %rdi
callq 0x8330
leaq -0xe8(%rbp), %rdi
callq 0x8330
movq -0x110(%rbp), %rsi
leaq -0x108(%rbp), %rdi
callq 0x9da50
jmp 0xaf7c8
movq -0x120(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x8640
jmp 0xaf7dd
leaq -0x108(%rbp), %rdi
callq 0x8330
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xaf8e1
jmp 0xaf8d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xaf8f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xaf853
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xaf84a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8330
leaq -0x58(%rbp), %rdi
callq 0x8330
leaq -0x78(%rbp), %rdi
callq 0x8330
jmp 0xaf8f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xaf8aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xaf89e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x8330
leaq -0xc8(%rbp), %rdi
callq 0x8330
leaq -0xe8(%rbp), %rdi
callq 0x8330
jmp 0xaf8f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x8330
jmp 0xaf8f1
movq -0x120(%rbp), %rdi
callq 0x8330
movq -0x118(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x120(%rbp), %rdi
callq 0x8330
movq -0x80(%rbp), %rdi
callq 0x8880
nopw %cs:(%rax,%rax)
// File: Kei18[P]pibt/./src/task/task.cpp
// Function: Task::Task(Node*)
Task::Task(Node* v) : id(cntId) {
  ++cntId;
  startTime = 0;
  endTime = 0;
  G_OPEN.push_back(v);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x3e880
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x30(%rbp)
callq 0x3e880
movq -0x28(%rbp), %rdi
movl 0x5017c(%rip), %eax     # 0x101964
movl %eax, 0x30(%rdi)
movl 0x50173(%rip), %eax     # 0x101964
incl %eax
movl %eax, 0x5016b(%rip)     # 0x101964
movl $0x0, 0x34(%rdi)
movl $0x0, 0x38(%rdi)
leaq -0x10(%rbp), %rsi
callq 0x3f490
jmp 0xb1812
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xd7d0
movq -0x28(%rbp), %rdi
callq 0xd7d0
movq -0x18(%rbp), %rdi
callq 0x8880
nop
// File: Kei18[P]pibt/./src/task/task.cpp
// Function: Task::Task(int)
Task::Task(int t) : id(cntId) {  // for mapd
  ++cntId;
  startTime = t;
  endTime = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x3e880
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x3e880
movq -0x18(%rbp), %rax
movl 0x500f1(%rip), %ecx     # 0x101964
movl %ecx, 0x30(%rax)
movl 0x500e8(%rip), %ecx     # 0x101964
addl $0x1, %ecx
movl %ecx, 0x500df(%rip)     # 0x101964
movl -0xc(%rbp), %ecx
movl %ecx, 0x34(%rax)
movl $0x0, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Kei18[P]pibt/./src/task/task.cpp
// Function: Task::Task(Node*, int)
Task::Task(Node* v, int t) : id(cntId) {
  ++cntId;
  startTime = t;
  endTime = 0;
  G_OPEN.push_back(v);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x3e880
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x38(%rbp)
callq 0x3e880
movq -0x30(%rbp), %rdi
movl 0x50089(%rip), %eax     # 0x101964
movl %eax, 0x30(%rdi)
movl 0x50080(%rip), %eax     # 0x101964
incl %eax
movl %eax, 0x50078(%rip)     # 0x101964
movl -0x14(%rbp), %eax
movl %eax, 0x34(%rdi)
movl $0x0, 0x38(%rdi)
leaq -0x10(%rbp), %rsi
callq 0x3f490
jmp 0xb1904
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xd7d0
movq -0x30(%rbp), %rdi
callq 0xd7d0
movq -0x20(%rbp), %rdi
callq 0x8880
nopw %cs:(%rax,%rax)
// File: Kei18[P]pibt/./src/task/task.cpp
// Function: Task::getNext(Node*)
Node* Task::getNext(Node* g) {
  auto itr = G_OPEN.begin();
  while (*itr != g || itr != G_OPEN.end()) ++itr;
  if (itr == G_OPEN.end()) return nullptr;
  ++itr;
  if (itr == G_OPEN.end()) return nullptr;
  return *itr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x3b730
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3bb00
movq (%rax), %rcx
movb $0x1, %al
cmpq -0x18(%rbp), %rcx
movb %al, -0x41(%rbp)
jne 0xb1be5
movq -0x40(%rbp), %rdi
callq 0x3b760
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3b790
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xb1bee
jmp 0xb1bf9
leaq -0x20(%rbp), %rdi
callq 0x3bad0
jmp 0xb1bb1
movq -0x40(%rbp), %rdi
callq 0x3b760
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3eba0
testb $0x1, %al
jne 0xb1c19
jmp 0xb1c23
movq $0x0, -0x8(%rbp)
jmp 0xb1c66
leaq -0x20(%rbp), %rdi
callq 0x3bad0
movq -0x40(%rbp), %rdi
callq 0x3b760
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3eba0
testb $0x1, %al
jne 0xb1c4c
jmp 0xb1c56
movq $0x0, -0x8(%rbp)
jmp 0xb1c66
leaq -0x20(%rbp), %rdi
callq 0x3bb00
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_16_main.cc
// Function: print(Vec<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
void print(const Vec<string>& svec)
{
	// c++11 Vec iterator
	for (auto it : svec)
		cout << it << " " ;
	cout <<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1700
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x139f
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x1070
movq -0x60(%rbp), %rsi
movq 0x2c7c(%rip), %rdi      # 0x3fd0
callq 0x10c0
movq %rax, -0x58(%rbp)
jmp 0x135f
movq -0x58(%rbp), %rdi
leaq 0xc9e(%rip), %rsi       # 0x2008
callq 0x10d0
jmp 0x1371
leaq -0x40(%rbp), %rdi
callq 0x1090
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
jmp 0x132e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1090
jmp 0x13b8
movq 0x2c2a(%rip), %rdi      # 0x3fd0
movq 0x2c13(%rip), %rsi      # 0x3fc0
callq 0x1100
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x1170
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_16_main.cc
// Function: getVec[abi:cxx11](std::istream&)
Vec<string> getVec(istream& is)
{
	Vec<string> svec;
	string s;
	while (is >> s)
		svec.push_back(s);
	return svec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1720
leaq -0x38(%rbp), %rdi
callq 0x1130
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1120
movq %rax, -0x60(%rbp)
jmp 0x1410
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x1110
movb %al, -0x61(%rbp)
jmp 0x1428
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x1431
jmp 0x1462
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1750
jmp 0x1440
jmp 0x13fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1090
movq -0x58(%rbp), %rdi
callq 0x17a0
jmp 0x1488
movb $0x1, -0x11(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1090
testb $0x1, -0x11(%rbp)
jne 0x147e
movq -0x58(%rbp), %rdi
callq 0x17a0
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x1170
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_16_main.cc
// Function: main
int main(int argc, char const *argv[])
{
	Vec<string> svec = getVec(cin);
	print(svec);

	cout << "copy " << svec.size() << endl;
	auto svec2 = svec;
	print(svec2);

	cout << "assign" << endl;
	Vec<string> svec3;
	svec3 = svec2;
	print(svec3);

	Vec<string> v1, v2;
	Vec<string> getVec(istream &);
	v1 = v2;           // copy assignment
	v2 = getVec(cin);  // move assignment

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x2b20(%rip), %rsi      # 0x3fe0
leaq -0x28(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x13d0
movq -0xb8(%rbp), %rdi
callq 0x1300
jmp 0x14de
movq 0x2aeb(%rip), %rdi      # 0x3fd0
leaq 0xb18(%rip), %rsi       # 0x2004
callq 0x10d0
movq %rax, -0xc0(%rbp)
jmp 0x14fa
leaq -0x28(%rbp), %rdi
callq 0x17d0
movq %rax, -0xc8(%rbp)
jmp 0x150c
movq -0xc8(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x1030
movq %rax, -0xd0(%rbp)
jmp 0x1528
movq -0xd0(%rbp), %rdi
movq 0x2a8a(%rip), %rsi      # 0x3fc0
callq 0x1100
jmp 0x153d
leaq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x17f0
jmp 0x154c
leaq -0x50(%rbp), %rdi
callq 0x1300
jmp 0x1557
movq 0x2a72(%rip), %rdi      # 0x3fd0
leaq 0xaa5(%rip), %rsi       # 0x200a
callq 0x10d0
movq %rax, -0xd8(%rbp)
jmp 0x1573
movq -0xd8(%rbp), %rdi
movq 0x2a3f(%rip), %rsi      # 0x3fc0
callq 0x1100
jmp 0x1588
leaq -0x68(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x1720
movq -0xe0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1870
jmp 0x15aa
leaq -0x68(%rbp), %rdi
callq 0x1300
jmp 0x15b5
leaq -0x80(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x1720
leaq -0x98(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x1720
movq -0xf0(%rbp), %rdi
movq -0xe8(%rbp), %rsi
callq 0x1870
jmp 0x15ed
movq 0x29ec(%rip), %rsi      # 0x3fe0
leaq -0xb0(%rbp), %rdi
callq 0x13d0
jmp 0x1602
leaq -0x98(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x18e0
leaq -0xb0(%rbp), %rdi
callq 0x17a0
movl $0x0, -0x4(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x17a0
leaq -0x80(%rbp), %rdi
callq 0x17a0
leaq -0x68(%rbp), %rdi
callq 0x17a0
leaq -0x50(%rbp), %rdi
callq 0x17a0
leaq -0x28(%rbp), %rdi
callq 0x17a0
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x16c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x16b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x16af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x17a0
leaq -0x80(%rbp), %rdi
callq 0x17a0
leaq -0x68(%rbp), %rdi
callq 0x17a0
leaq -0x50(%rbp), %rdi
callq 0x17a0
leaq -0x28(%rbp), %rdi
callq 0x17a0
movq -0x30(%rbp), %rdi
callq 0x1170
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/./Vec.h
// Function: Vec<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Vec(Vec<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
inline Vec<T>::Vec(const Vec& s)
{
	// call copy to allocate exactly as many elements as in s
	auto newdata = alloc_n_copy(s.begin(), s.end());
	elements = newdata.first;
	first_free = cap = newdata.second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x16e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1700
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
movq %rax, %rdx
callq 0x1cd0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/./Vec.h
// Function: Vec<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator=(Vec<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
inline Vec<T>& Vec<T>::operator=(const Vec& rhs)
{
	// call copy to allocate exactly as many elements as in rhs
	auto data = alloc_n_copy(rhs.begin(), rhs.end());
	free();
	elements = data.first;
	first_free = cap = data.second;
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1700
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
movq %rax, %rdx
callq 0x1cd0
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x19b0
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/./Vec.h
// Function: Vec<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator=(Vec<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&&)
inline Vec<T>& Vec<T>::operator=(Vec&& rhs) noexcept
{
	// direct test for self-assignment
	if (this != &rhs)
		free();  // free existing elements if appropriate

	elements = rhs.elements;  // take over resources from rhs
	first_free = rhs.first_free;
	cap = rhs.cap;

	// leave rhs in a destructible state
	rhs.elements = rhs.first_free = rhs.cap = nullptr;

	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x190b
movq -0x18(%rbp), %rdi
callq 0x19b0
jmp 0x1909
jmp 0x190b
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq $0x0, 0x10(%rcx)
movq -0x10(%rbp), %rcx
movq $0x0, 0x8(%rcx)
movq -0x10(%rbp), %rcx
movq $0x0, (%rcx)
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1a30
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/./Vec.h
// Function: Vec<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::free()
inline void Vec<T>::free()
{
	// destroy the old elements in reverse order
	for (auto p = first_free; p != elements; /* empty */)
		alloc.destroy(--p);  // destroy elements in reverse order

	// deallocate cannot be called on a 0 pointer
	if (elements)
		alloc.deallocate(elements, cap - elements);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq (%rcx), %rax
je 0x19f3
movq -0x10(%rbp), %rsi
addq $-0x20, %rsi
movq %rsi, -0x10(%rbp)
leaq 0x26ee(%rip), %rdi      # 0x40da
callq 0x1a40
jmp 0x19cc
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1a1e
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq 0x10(%rax), %rdx
movq (%rax), %rax
subq %rax, %rdx
sarq $0x5, %rdx
leaq 0x26c1(%rip), %rdi      # 0x40da
callq 0x1a60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/./Vec.h
// Function: Vec<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::reallocate()
inline void Vec<T>::reallocate()
{
	// we'll allocate space for twice as many elements as current size
	auto newcapacity = size() ? 2 * size() : 2;

	// allocate new space
	auto first = alloc.allocate(newcapacity);
	auto dest = first;
	auto elem = elements;

	// move the elements
	for (size_t i = 0; i != size(); ++i)
		alloc.construct(dest++, std::move(*elem++));
	free();  // free the old space once we've moved the elements

	// update our data structure point to the new elements
	elements = first;
	first_free = dest;
	cap = elements + newcapacity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x17d0
cmpq $0x0, %rax
je 0x1b41
movq -0x38(%rbp), %rdi
callq 0x17d0
shlq %rax
movq %rax, -0x40(%rbp)
jmp 0x1b4c
movl $0x2, %eax
movq %rax, -0x40(%rbp)
jmp 0x1b4c
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x257b(%rip), %rdi      # 0x40da
xorl %eax, %eax
movl %eax, %edx
callq 0x1c20
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x17d0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
je 0x1bdf
movq -0x20(%rbp), %rsi
movq %rsi, %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdx
movq %rdx, %rax
addq $0x20, %rax
movq %rax, -0x28(%rbp)
leaq 0x250e(%rip), %rdi      # 0x40da
callq 0x1c80
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1b8a
movq -0x38(%rbp), %rdi
callq 0x19b0
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq (%rax), %rcx
movq -0x10(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: donqustix[P]SoftwareRenderer/src/main.cpp
// Function: (anonymous namespace)::Matrix<float>::create_perspective(float, float, float, float)
static constexpr Matrix create_perspective(T fov, T aspect, T znear, T zfar) noexcept
        {
            const T f = 1 / std::tan(fov / 2), A =    (zfar + znear) / (znear - zfar),
                                               B = 2 * zfar * znear  / (znear - zfar);

            return Matrix{{f / aspect, T{}, T{}, T{},
                                  T{},   f, T{}, T{},
                                  T{}, T{},   A,   B,
                                  T{}, T{},  -1,  T{}}};
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, -0x68(%rbp)
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movss %xmm3, -0x10(%rbp)
movss -0x4(%rbp), %xmm0
movss 0x4f87(%rip), %xmm1     # 0x8038
mulss %xmm1, %xmm0
callq 0x7c20
movss %xmm0, -0x60(%rbp)
jmp 0x30c1
movq -0x70(%rbp), %rdi
movss -0x60(%rbp), %xmm1
movss 0x4f42(%rip), %xmm0     # 0x8014
divss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x10(%rbp), %xmm0
addss -0xc(%rbp), %xmm0
movss -0xc(%rbp), %xmm1
subss -0x10(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movss 0x4f10(%rip), %xmm0     # 0x8010
mulss -0x10(%rbp), %xmm0
mulss -0xc(%rbp), %xmm0
movss -0xc(%rbp), %xmm1
subss -0x10(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x14(%rbp), %xmm0
divss -0x8(%rbp), %xmm0
movss %xmm0, -0x5c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x58(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x54(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x50(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x4c(%rbp)
movss -0x14(%rbp), %xmm0
movss %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x44(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x3c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x38(%rbp)
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movss 0x4e92(%rip), %xmm0     # 0x8034
movss %xmm0, -0x24(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
leaq -0x5c(%rbp), %rsi
callq 0x5620
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x70a0
nopw (%rax,%rax)
// File: donqustix[P]SoftwareRenderer/src/main.cpp
// Function: (anonymous namespace)::Matrix<float>::operator*((anonymous namespace)::Matrix<float> const&) const
constexpr Matrix operator*(const Matrix& matrix) const noexcept
        {
            Matrix temp;
            for (auto i = 0; i < 4; ++i)
                for (auto j = 0; j < 4; ++j)
                    for (auto k = 0; k < 4; ++k)
                        *(temp.data + i * 4 + j) += *(data + i * 4 + k) * *(matrix.data + k * 4 + j);

            return temp;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x56a0
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x32b6
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x32a6
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x3296
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %edx
shll $0x2, %edx
movslq %edx, %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movslq -0x1c(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm0
movq -0x10(%rbp), %rcx
movl -0x1c(%rbp), %edx
shll $0x2, %edx
movslq %edx, %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
movslq -0x18(%rbp), %rdx
movss (%rcx,%rdx,4), %xmm2
movl -0x14(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movss (%rax,%rcx,4), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3221
jmp 0x3298
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3210
jmp 0x32a8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x31ff
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: donqustix[P]SoftwareRenderer/src/main.cpp
// Function: (anonymous namespace)::Matrix<float>::create_translation(float, float, float)
static constexpr Matrix create_translation(T x, T y, T z) noexcept
        {
            return Matrix{{static_cast<T>(1),               T{},               T{},                x,
                                         T{}, static_cast<T>(1),               T{},                y,
                                         T{},               T{}, static_cast<T>(1),                z,
                                         T{},               T{},               T{}, static_cast<T>(1)}};
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movss 0x4d2e(%rip), %xmm0     # 0x8014
movss %xmm0, -0x4c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x44(%rbp)
movss -0x4(%rbp), %xmm0
movss %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x3c(%rbp)
movss 0x4cff(%rip), %xmm0     # 0x8014
movss %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movss 0x4cd0(%rip), %xmm0     # 0x8014
movss %xmm0, -0x24(%rbp)
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movss 0x4ca1(%rip), %xmm0     # 0x8014
movss %xmm0, -0x10(%rbp)
leaq -0x4c(%rbp), %rsi
callq 0x5620
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: donqustix[P]SoftwareRenderer/src/main.cpp
// Function: (anonymous namespace)::Matrix<float>::create_scaling(float, float, float)
static constexpr Matrix create_scaling(T x, T y, T z) noexcept
        {
            return Matrix{{x, T{}, T{}, T{},
                           T{}, y, T{}, T{},
                           T{}, T{}, z, T{},
                           T{}, T{}, T{}, static_cast<T>(1)}};
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
leaq -0x4c(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2140
movq -0x60(%rbp), %rdi
movss -0x4(%rbp), %xmm0
movss %xmm0, -0x4c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x44(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movss 0x4bcb(%rip), %xmm0     # 0x8014
movss %xmm0, -0x10(%rbp)
leaq -0x4c(%rbp), %rsi
callq 0x5620
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: donqustix[P]SoftwareRenderer/src/main.cpp
// Function: (anonymous namespace)::Matrix<float>::create_rotation_y(float)
static constexpr Matrix create_rotation_y(T angle) noexcept
        {
            const T cos_ = std::cos(angle), sin_ = std::sin(angle);

            return Matrix{{ cos_,               T{}, sin_,               T{},
                             T{}, static_cast<T>(1),  T{},               T{},
                           -sin_,               T{}, cos_,               T{},
                             T{},               T{},  T{}, static_cast<T>(1)}};
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
callq 0x7c40
movss %xmm0, -0x50(%rbp)
jmp 0x3496
movss -0x50(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x4(%rbp), %xmm0
callq 0x7c60
movss %xmm0, -0x64(%rbp)
jmp 0x34b1
movq -0x60(%rbp), %rdi
movss -0x64(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x4c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x48(%rbp)
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x3c(%rbp)
movss 0x4b21(%rip), %xmm0     # 0x8014
movss %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
movss -0xc(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x2c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movss 0x4abb(%rip), %xmm0     # 0x8014
movss %xmm0, -0x10(%rbp)
leaq -0x4c(%rbp), %rsi
callq 0x5620
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x70a0
nopl (%rax)
// File: donqustix[P]SoftwareRenderer/src/main.cpp
// Function: (anonymous namespace)::Matrix<float>::create_rotation_x(float)
static constexpr Matrix create_rotation_x(T angle) noexcept
        {
            const T cos_ = std::cos(angle), sin_ = std::sin(angle);

            return Matrix{{static_cast<T>(1),  T{},   T{},              T{},
                                         T{}, cos_, -sin_,              T{},
                                         T{}, sin_,  cos_,              T{},
                                         T{},  T{},   T{}, static_cast<T>(1)}};
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, -0x58(%rbp)
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
callq 0x7c40
movss %xmm0, -0x8(%rbp)
movss -0x4(%rbp), %xmm0
callq 0x7c60
movq -0x60(%rbp), %rdi
movss %xmm0, -0xc(%rbp)
movss 0x4a55(%rip), %xmm0     # 0x8014
movss %xmm0, -0x4c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x44(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x40(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x38(%rbp)
movss -0xc(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x34(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movss 0x49c3(%rip), %xmm0     # 0x8014
movss %xmm0, -0x10(%rbp)
leaq -0x4c(%rbp), %rsi
callq 0x5620
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: donqustix[P]SoftwareRenderer/src/main.cpp
// Function: (anonymous namespace)::operator*((anonymous namespace)::Matrix<float> const&, (anonymous namespace)::Vector<float> const&)
constexpr Vector operator*(const Matrix<T>& matrix, const Vector& vector) noexcept
        {
            Vector temp;
            for (auto i = 0; i < 4; ++i)
                *(temp.data + i) = matrix(i, 0) * *vector.data + matrix(i, 1) * *(vector.data + 1) +
                                                                 matrix(i, 2) * *(vector.data + 2) +
                                                                 matrix(i, 3) * *(vector.data + 3);
            return temp;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x5d40
movl $0x0, -0x24(%rbp)
cmpl $0x4, -0x24(%rbp)
jge 0x57e9
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
xorl %edx, %edx
callq 0x5d80
movss %xmm0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0x34(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
movl $0x1, %edx
callq 0x5d80
movss -0x34(%rbp), %xmm2
movaps %xmm0, %xmm1
movss -0x30(%rbp), %xmm0
movq -0x20(%rbp), %rax
mulss 0x4(%rax), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
movl $0x2, %edx
callq 0x5d80
movss -0x2c(%rbp), %xmm1
movq -0x20(%rbp), %rax
movss 0x8(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
movl $0x3, %edx
callq 0x5d80
movss -0x28(%rbp), %xmm1
movq -0x20(%rbp), %rax
movss 0xc(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movslq -0x24(%rbp), %rax
movss %xmm0, -0x10(%rbp,%rax,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5720
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: donqustix[P]SoftwareRenderer/src/main.cpp
// Function: (anonymous namespace)::Matrix<float>::create_screenspace(float, float)
static constexpr Matrix create_screenspace(T width, T height) noexcept
        {
            const auto half_width = width / 2, half_height = height / 2;

            return Matrix{{half_width,          T{},               T{},       half_width,
                                  T{}, -half_height,               T{},      half_height,
                                  T{},          T{}, static_cast<T>(1),              T{},
                                  T{},          T{},               T{}, static_cast<T>(1)}};
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss -0x4(%rbp), %xmm0
movss 0x26aa(%rip), %xmm1     # 0x8010
divss %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
movss 0x2694(%rip), %xmm1     # 0x8010
divss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x50(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x4c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x48(%rbp)
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x40(%rbp)
movss -0x10(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x3c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x38(%rbp)
movss -0x10(%rbp), %xmm0
movss %xmm0, -0x34(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x2c(%rbp)
movss 0x2622(%rip), %xmm0     # 0x8014
movss %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x18(%rbp)
movss 0x25f5(%rip), %xmm0     # 0x8014
movss %xmm0, -0x14(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x5620
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Joke-Shi[P]astrunc/sample/sample_zh.cc
// Function: main
int main( int argc, const char **argv)
{
    std::string s_zh = "Prometheus，它的价值在于可靠性，甚至在很恶劣的环境下，你都可以随时访问它和查"
                       "书名《恶搞》““ABC等。”“。””，《你好啊《是的》。是吗》，“不知道怎说才好”“哎！”"
                       "看系统服务各种指标的统计信息。 如果你对统计数据需要100%的精确，它并不适用，例"
                       "如：它不适用于实时计费系统。";

    std::vector< std::string> vec_s;
    int rc = astrunc::access::split( vec_s, s_zh, astrunc::access::ZH, 32);
    if ( 0 == rc) {
        for ( auto const &__s : vec_s) {
            std::cout << __s << std::endl;
            std::cout << "------------------------------------------------------------------\n";
        }
    } else { std::cerr << "[Error]: Split error\n"; }


    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x22b0
movq -0x90(%rbp), %rdx
leaq 0x2285(%rip), %rsi      # 0xb20c
leaq -0x30(%rbp), %rdi
callq 0x9170
jmp 0x8f92
leaq -0x31(%rbp), %rdi
callq 0x21c0
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x9310
movq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x46, %edx
movl $0x20, %ecx
callq 0x49d0
movl %eax, -0x94(%rbp)
jmp 0x8fcd
movl -0x94(%rbp), %eax
movl %eax, -0x64(%rbp)
xorl %eax, %eax
cmpl -0x64(%rbp), %eax
jne 0x90b5
leaq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x9330
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
callq 0x9360
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x9390
testb $0x1, %al
jne 0x9019
jmp 0x90b3
leaq -0x78(%rbp), %rdi
callq 0x93d0
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rsi
movq 0x5f99(%rip), %rdi      # 0xefd0
callq 0x2160
movq %rax, -0xa8(%rbp)
jmp 0x9045
movq -0xa8(%rbp), %rdi
movq 0x5f65(%rip), %rsi      # 0xefb8
callq 0x21a0
jmp 0x905a
movq 0x5f6f(%rip), %rdi      # 0xefd0
leaq 0x232e(%rip), %rsi      # 0xb396
callq 0x2170
jmp 0x906f
jmp 0x9071
leaq -0x78(%rbp), %rdi
callq 0x93f0
jmp 0x9003
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x21c0
jmp 0x90f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x9410
leaq -0x30(%rbp), %rdi
callq 0x22f8
jmp 0x90f0
jmp 0x90cc
movq 0x5f34(%rip), %rdi      # 0xeff0
leaq 0x2317(%rip), %rsi      # 0xb3da
callq 0x2170
jmp 0x90ca
jmp 0x90cc
movl -0x64(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x9410
leaq -0x30(%rbp), %rdi
callq 0x22f8
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x22a0
nopl (%rax)
// File: dustin[P]kvtest/example-test.cc
// Function: SimpleThing::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, kvtest::Callback<kvtest::GetValue>&)
void get(std::string &key, kvtest::Callback<kvtest::GetValue> &cb) {
        std::map<std::string, std::string>::iterator it = storage.find(key);
        bool success = it != storage.end();
        kvtest::GetValue rv(success ? it->second : std::string(":("),
                            success);
        cb.callback(rv);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x5480
movq -0x98(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x3f40
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x54b0
andb $0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
movb $0x0, -0x79(%rbp)
movb $0x0, -0x7b(%rbp)
movb $0x0, -0x8d(%rbp)
testb $0x1, %al
je 0x3aee
leaq -0x20(%rbp), %rdi
callq 0x54e0
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x78(%rbp), %rdi
callq 0x30f0
movb $0x1, -0x79(%rbp)
jmp 0x3b22
leaq -0x7a(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3460
movq -0xa0(%rbp), %rdx
movb $0x1, -0x7b(%rbp)
leaq 0xa53f(%rip), %rsi      # 0xe04f
leaq -0x78(%rbp), %rdi
callq 0x5140
jmp 0x3b1b
movb $0x1, -0x8d(%rbp)
movzbl -0x21(%rbp), %edx
andl $0x1, %edx
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x5500
jmp 0x3b38
testb $0x1, -0x8d(%rbp)
jne 0x3b43
jmp 0x3b4c
leaq -0x78(%rbp), %rdi
callq 0x3160
testb $0x1, -0x7b(%rbp)
jne 0x3b54
jmp 0x3b5d
leaq -0x7a(%rbp), %rdi
callq 0x32e0
testb $0x1, -0x79(%rbp)
jne 0x3b65
jmp 0x3b6e
leaq -0x78(%rbp), %rdi
callq 0x3160
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq -0x58(%rbp), %rsi
callq *%rax
jmp 0x3b81
leaq -0x58(%rbp), %rdi
callq 0x5570
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x3bcf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
testb $0x1, -0x8d(%rbp)
jne 0x3bc4
jmp 0x3bcd
leaq -0x78(%rbp), %rdi
callq 0x3160
jmp 0x3bcf
testb $0x1, -0x7b(%rbp)
jne 0x3bd7
jmp 0x3be0
leaq -0x7a(%rbp), %rdi
callq 0x32e0
testb $0x1, -0x79(%rbp)
jne 0x3be8
jmp 0x3bf1
leaq -0x78(%rbp), %rdi
callq 0x3160
jmp 0x3c0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5570
movq -0x88(%rbp), %rdi
callq 0x3450
nopw (%rax,%rax)
// File: dustin[P]kvtest/example-test.cc
// Function: SimpleThing::del(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, kvtest::Callback<bool>&)
void del(std::string &key, kvtest::Callback<bool> &cb) {
        bool rv = true;
        if(storage.find(key) == storage.end()) {
            rv = false;
        }
        storage.erase(key);
        cb.callback(rv);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movb $0x1, -0x19(%rbp)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x5480
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
callq 0x3f40
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3f10
testb $0x1, %al
jne 0x3c75
jmp 0x3c79
movb $0x0, -0x19(%rbp)
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x5640
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
leaq -0x19(%rbp), %rsi
callq *0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nop
// File: dustin[P]kvtest/tests.cc
// Function: setup_alarm(int)
static void setup_alarm(int duration) {
    struct sigaction sig_handler;

    sig_handler.sa_handler = caught_alarm;
    sig_handler.sa_flags = 0;

    sigaction(SIGALRM, &sig_handler, NULL);

    alarmed = false;
    alarm(duration);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x4(%rbp)
leaq 0x47b(%rip), %rax       # 0x6d40
movq %rax, -0xa0(%rbp)
movl $0x0, -0x18(%rbp)
movl $0xe, %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3390
movb $0x0, 0xe9cc(%rip)      # 0x152bb
movl -0x4(%rbp), %edi
callq 0x34b0
addq $0xa0, %rsp
popq %rbp
retq
// File: dustin[P]kvtest/./callbacks.hh
// Function: kvtest::RememberingCallback<kvtest::GetValue>::RememberingCallback()
RememberingCallback() {
            if(pthread_mutex_init(&mutex, NULL) != 0) {
                throw std::runtime_error("Failed to initialize mutex.");
            }
            if(pthread_cond_init(&cond, NULL) != 0) {
                throw std::runtime_error("Failed to initialize condition.");
            }
            fired = false;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x7d70
movq -0x28(%rbp), %rdi
leaq 0xdb74(%rip), %rax      # 0x14c68
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x20(%rbp)
callq 0x7d90
jmp 0x7106
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x33e0
cmpl $0x0, %eax
je 0x7193
movl $0x10, %edi
callq 0x3110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x70fc(%rip), %rsi      # 0xe233
callq 0x30c0
jmp 0x713e
movq -0x30(%rbp), %rdi
movq 0xdea7(%rip), %rsi      # 0x14ff0
movq 0xde68(%rip), %rdx      # 0x14fb8
callq 0x3430
jmp 0x7224
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x7212
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x31d0
jmp 0x7209
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x7209
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3350
cmpl $0x0, %eax
je 0x71fb
movl $0x10, %edi
callq 0x3110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x708b(%rip), %rsi      # 0xe24f
callq 0x30c0
jmp 0x71cb
movq -0x38(%rbp), %rdi
movq 0xde1a(%rip), %rsi      # 0x14ff0
movq 0xdddb(%rip), %rdx      # 0x14fb8
callq 0x3430
jmp 0x7224
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x31d0
jmp 0x7209
movq -0x28(%rbp), %rax
movb $0x0, 0x30(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5570
movq -0x28(%rbp), %rdi
callq 0x7eb0
movq -0x10(%rbp), %rdi
callq 0x3450
nopw %cs:(%rax,%rax)
nop