LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::isFree(Node*)
bool PPS::isFree(Node* v) {
  bool flg = std::none_of(A.begin(), A.end(),
                          [v](Agent* a) { return a->getNode() == v; });
  flg &= !inArray(v, L);
  return flg;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq 0x28(%rdi), %rax
movq %rax, %rdi
subq %r14, %rdi
movq %rdi, %rdx
sarq $0x5, %rdx
testq %rdx, %rdx
jle 0x3ce72
andq $-0x20, %rdi
movq %rdi, %rcx
addq %r14, %rcx
incq %rdx
addq $0x10, %r14
movq -0x10(%r14), %rdi
cmpq %rsi, 0x8(%rdi)
je 0x3ceb8
movq -0x8(%r14), %rdi
cmpq %rsi, 0x8(%rdi)
je 0x3cebe
movq (%r14), %rdi
cmpq %rsi, 0x8(%rdi)
je 0x3cec8
movq 0x8(%r14), %rdi
cmpq %rsi, 0x8(%rdi)
je 0x3cec4
decq %rdx
addq $0x20, %r14
cmpq $0x1, %rdx
jg 0x3ce36
movq %rax, %rdi
subq %rcx, %rdi
jmp 0x3ce75
movq %r14, %rcx
sarq $0x3, %rdi
cmpq $0x1, %rdi
je 0x3cea8
cmpq $0x2, %rdi
je 0x3ce9b
movq %rax, %r14
cmpq $0x3, %rdi
jne 0x3cec8
movq (%rcx), %rdx
cmpq %rsi, 0x8(%rdx)
je 0x3ceb3
addq $0x8, %rcx
movq (%rcx), %rdx
cmpq %rsi, 0x8(%rdx)
je 0x3ceb3
addq $0x8, %rcx
movq (%rcx), %rdx
cmpq %rsi, 0x8(%rdx)
cmovneq %rax, %rcx
movq %rcx, %r14
jmp 0x3cec8
addq $-0x10, %r14
jmp 0x3cec8
addq $-0x8, %r14
jmp 0x3cec8
addq $0x8, %r14
xorq %rax, %r14
movq %rsp, %rdx
movq %rsi, (%rdx)
movq 0x110(%rbx), %rdi
movq 0x118(%rbx), %rsi
callq 0x19b2e
xorq 0x118(%rbx), %rax
orq %r14, %rax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::logStr[abi:cxx11]()
std::string PPS::logStr() {
  std::string str;
  str += "[solver] type:Parallel Push & Swap\n";
  str += Solver::logStr();
  return str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0xe851(%rip), %rsi      # 0x4b774
callq 0x6690
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3f4ea
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6120
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3cf5f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3cf91
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
jmp 0x3cf91
jmp 0x3cf8e
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3cfa4
movq (%r15), %rsi
incq %rsi
callq 0x6380
movq %r14, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/solver/solver.cpp
// Function: Solver::init()
void Solver::init() {
  G = P->getG();
  A = P->getA();
  int nodeNum = G->getNodesNum();
  dists = Eigen::MatrixXi::Zero(nodeNum, nodeNum);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq 0x10(%rsi), %rax
movq %rax, 0x38(%rdi)
addq $0x18, %rsi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xb55c
movq 0x20(%rbx), %rdi
movq 0x30(%rbx), %rsi
movaps (%r14), %xmm0
movups %xmm0, 0x20(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x30(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
testq %rdi, %rdi
je 0x3e360
subq %rdi, %rsi
callq 0x6380
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3e360
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq 0x38(%rbx), %rax
movq 0x18(%rax), %rcx
subq 0x10(%rax), %rcx
shrq $0x3, %rcx
movslq %ecx, %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
testq %rax, %rax
js 0x3e3a8
addq $0x40, %rbx
leaq 0x10(%rsp), %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x3fb8b
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0xc4e2(%rip), %rdi      # 0x4a891
leaq 0xc570(%rip), %rsi      # 0x4a926
leaq 0xd504(%rip), %rcx      # 0x4b8c1
movl $0x4a, %edx
callq 0x6260
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/solver/solver.cpp
// Function: Solver::formalizePath(std::vector<std::vector<Node*, std::allocator<Node*>>, std::allocator<std::vector<Node*, std::allocator<Node*>>>>&)
void Solver::formalizePath(Paths& paths) {
  int maxLength = getMaxLengthPaths(paths);
  Node* g;
  for (int i = 0; i < paths.size(); ++i) {
    g = paths[i][paths[i].size() - 1];
    while (paths[i].size() != maxLength) paths[i].push_back(g);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x3ee0c
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
cmpq %rcx, %rdx
je 0x3efaf
movslq %eax, %r15
xorl %r12d, %r12d
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
movq %rsp, %r14
leaq (%r12,%r12,2), %rbp
movq 0x8(%rcx,%rbp,8), %rax
movq -0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rcx,%rbp,8), %rsi
movq %rsi, %rax
subq (%rcx,%rbp,8), %rax
sarq $0x3, %rax
cmpq %r15, %rax
je 0x3ef95
leaq (%rcx,%rbp,8), %rdi
leaq (%rcx,%rbp,8), %rax
addq $0x8, %rax
cmpq 0x10(%rdi), %rsi
je 0x3ef67
movq (%rsp), %rcx
movq %rcx, (%rsi)
addq $0x8, (%rax)
jmp 0x3ef6f
movq %r14, %rdx
callq 0x1c5cc
movq (%rbx), %rcx
leaq (%rcx,%rbp,8), %rdi
leaq (%rcx,%rbp,8), %rax
addq $0x8, %rax
movq (%rax), %rsi
movq %rsi, %rdx
subq -0x8(%rax), %rdx
sarq $0x3, %rdx
cmpq %r15, %rdx
jne 0x3ef54
movq 0x8(%rbx), %rdx
incq %r12
movq %rdx, %rax
subq %rcx, %rax
sarq $0x3, %rax
imulq %r13, %rax
cmpq %r12, %rax
ja 0x3ef22
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/solver/solver.cpp
// Function: Solver::getKey[abi:cxx11](int, Node*)
std::string Solver::getKey(int t, Node* v) {
  std::string key = "";
  key += std::to_string(t);
  key += "-";
  key += std::to_string(v->getId());
  return key;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
leaq 0x9262(%rip), %rdx      # 0x48564
movq %rdx, %rsi
callq 0xb8a6
movl %r15d, %ebp
negl %ebp
cmovsl %r15d, %ebp
movl $0x1, %r12d
cmpl $0xa, %ebp
jb 0x3f367
movl $0x4, %r12d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x3f35e
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x3f364
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x3f367
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r12d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x3f32b
addl $-0x3, %r12d
jmp 0x3f367
addl $-0x2, %r12d
jmp 0x3f367
decl %r12d
shrl $0x1f, %r15d
leal (%r12,%r15), %esi
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rsp, %rdi
movl $0x2d, %edx
callq 0x6410
movl %r15d, %edi
addq (%rsp), %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0xb7a2
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6120
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3f3bd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
leaq 0xca93(%rip), %rsi      # 0x4be57
movq %rbx, %rdi
callq 0x6690
movl (%r14), %r14d
movl %r14d, %ebp
negl %ebp
cmovsl %r14d, %ebp
movl $0x1, %r15d
cmpl $0xa, %ebp
jb 0x3f42c
movl $0x4, %r15d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x3f423
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x3f429
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x3f42c
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r15d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x3f3f0
addl $-0x3, %r15d
jmp 0x3f42c
addl $-0x2, %r15d
jmp 0x3f42c
decl %r15d
shrl $0x1f, %r14d
leal (%r15,%r14), %esi
movq %rsp, %rdi
movq %r13, (%rdi)
movl $0x2d, %edx
callq 0x6410
addq (%rsp), %r14
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0xb7a2
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6120
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3f47c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3f494
jmp 0x3f4af
jmp 0x3f4af
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3f4b2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
jmp 0x3f4b2
movq %rax, %r14
movq (%rbx), %rdi
cmpq 0x20(%rsp), %rdi
je 0x3f4cc
movq 0x20(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x6380
movq %r14, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/solver/tp.cpp
// Function: TP::init()
void TP::init() {
  timestep = 0;
  status = true;
  P->setAutoAssignement(false);

  G->setRegFlg(true);

  // initialize
  for (auto a : A) paths.push_back({ a->getNode() });
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x0, 0x68(%rdi)
movb $0x1, %bpl
movb %bpl, 0xa0(%rdi)
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x28(%rax)
movq 0x38(%rbx), %rax
movb %bpl, 0x9(%rax)
movq 0x20(%rbx), %r13
movq 0x28(%rbx), %rbp
cmpq %rbp, %r13
je 0x3ff8e
addq $0x88, %rbx
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %r12
movq (%r13), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0xb484
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18c56
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3ff85
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x3ff43
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3ffb7
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
callq 0x6620
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/solver/tp.cpp
// Function: TP::solve()
bool TP::solve() {
  solveStart();

  while (!P->isSolved()) {
    ++timestep;
    update();

    if (!status) {
      solveEnd();
      return false;  // failed
    }

    P->update();
    if (P->getTimestep() >= P->getTimestepLimit()) break;
  }

  solveEnd();
  return true;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movb $0x1, %bpl
testb %al, %al
jne 0x40114
incl 0x68(%rbx)
movq %rbx, %rdi
callq 0x40126
cmpb $0x1, 0xa0(%rbx)
jne 0x40112
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rbx), %rdi
movl 0x8(%rdi), %eax
cmpl 0xc(%rdi), %eax
jl 0x400d9
jmp 0x40114
xorl %ebp, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/solver/tp.cpp
// Function: TP::update()
bool TP::shouldAvoid(Agent* a, int timestep) {
  Node* v = a->getNode();
  Node* g;

  for (auto tau : P->getT()) {
    g = tau->getG()[tau->getG().size() - 1];  // delivery points
    if (g == v) return true;
  }
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x20(%rdi), %rax
cmpq %rax, 0x28(%rdi)
je 0x4031e
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %ebp, %ebp
movq 0x88(%rbx), %rcx
movq 0x8(%rcx,%r15), %rdx
subq (%rcx,%r15), %rdx
movq (%rax,%r12,8), %r13
sarq $0x3, %rdx
movslq 0x68(%rbx), %rax
cmpq %rax, %rdx
jbe 0x40187
movq %rbp, %r14
jmp 0x402ca
movq 0x8(%r13), %rax
movq %rax, 0x48(%rsp)
movq %rsp, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x40354
movq 0x30(%rsp), %rsi
movq (%rsp), %rax
movq 0x8(%rsp), %r14
movq %rax, 0x40(%rsp)
movq %rax, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
testq %rbp, %rbp
je 0x401fb
subq %rbp, %rsi
movq %rbp, %rdi
callq 0x6380
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x401fb
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq 0x40(%rsp), %rax
cmpq %r14, %rax
je 0x40278
movq %rbx, %rdi
movq %r13, %rsi
leaq 0x20(%rsp), %rdx
callq 0x40688
movq %rax, %rbp
movq %rax, 0x18(%r13)
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x25936
movq %rsp, %rdi
movq %rbp, %rsi
callq 0x19aae
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
movq %rax, 0x50(%rsp)
movq 0x8(%r13), %r14
subq %rdi, %rsi
callq 0x6380
cmpq %r14, 0x50(%rsp)
movq 0x40(%rsp), %r14
jne 0x40268
movq 0x8(%r13), %rsi
movq %rbp, %rdi
callq 0x47282
movl 0x68(%rbx), %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x407da
jmp 0x402ca
movq %rax, %r14
movq %rbx, %rdi
movq %r13, %rsi
callq 0x409c6
testb %al, %al
je 0x4029a
movl 0x68(%rbx), %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x40aec
jmp 0x402ca
movq 0x88(%rbx), %rax
leaq (%rax,%r15), %rdi
movq 0x8(%rax,%r15), %rsi
cmpq 0x10(%rax,%r15), %rsi
je 0x402c0
movq 0x48(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x402ca
leaq 0x48(%rsp), %rdx
callq 0x1c5cc
movq 0x88(%rbx), %rax
movslq 0x68(%rbx), %rcx
movq (%rax,%r15), %rax
movq (%rax,%rcx,8), %rsi
movq %r13, %rdi
callq 0x191f2
incq %r12
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
addq $0x18, %r15
movq %r14, %rbp
cmpq %r12, %rcx
ja 0x4015e
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x4031e
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x40331
jmp 0x40331
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x4034b
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
callq 0x6620
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/solver/tp.cpp
// Function: TP::updatePath1(Agent*, int)
void TP::updatePath1(Agent* a, int startTime) {
  auto itr = std::find(A.begin(), A.end(), a);
  int i = std::distance(A.begin(), itr);

  Nodes gs = a->getTask()->getG();
  a->setGoal(gs[gs.size() - 1]);  // delivery point

  Nodes p;
  Nodes path = { a->getNode() };

  if (gs.size() == 2) {
    path = getPickDelivPath(a, a->getNode(), gs[0], gs[1], startTime, true);
  } else if (gs.size() == 1) {
    path = getPath(a, a->getNode(), gs[0], startTime, gs[0]);
  }

  paths[i].insert(paths[i].end(), path.begin() + 1, path.end());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %edx, %r15d
movq %rdi, %rbx
leaq 0x50(%rsp), %r12
movq %rsi, (%r12)
movq 0x20(%rdi), %rdi
movq 0x28(%rbx), %rsi
movq %r12, %rdx
callq 0x388d5
movq %rax, %r14
subq 0x20(%rbx), %r14
movq (%r12), %rax
movq 0x18(%rax), %rsi
leaq 0x58(%rsp), %r13
movq %r13, %rdi
callq 0x19aae
movq (%r12), %rax
movq 0x8(%r13), %rcx
movq -0x8(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rax), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
callq 0xb484
movq 0x58(%rsp), %rax
movq 0x60(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq $0x1, %rcx
je 0x4089a
cmpq $0x2, %rcx
jne 0x4091a
movq 0x50(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq (%rax), %r8
movq 0x8(%rax), %r9
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
pushq $0x1
pushq %r15
callq 0x41004
addq $0x10, %rsp
jmp 0x408c7
movq 0x50(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq (%rax), %r8
xorl %eax, %eax
testq %r8, %r8
setne %al
subq $0x8, %rsp
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
movl %r15d, %r9d
pushq %rax
callq 0x41ae4
addq $0x10, %rsp
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
movaps 0x10(%rsp), %xmm0
movaps %xmm0, 0x30(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
testq %rdi, %rdi
je 0x4091a
subq %rdi, %rsi
callq 0x6380
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4091a
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
shrq $0x3, %r14
movslq %r14d, %rax
movq 0x88(%rbx), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rdi
movq 0x8(%rdi), %rsi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
addq $0x8, %rdx
callq 0x427fc
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x4095e
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x40975
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x40987
jmp 0x40987
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x409a6
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
jmp 0x409a6
movq %rax, %rbx
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x409bd
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
callq 0x6620
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/solver/tp.cpp
// Function: TP::logStr[abi:cxx11]()
std::string TP::logStr() {
  std::string str;
  str += "[solver] type:TP\n";
  str += Solver::logStr();
  return str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x98d2(%rip), %rsi      # 0x4be2f
callq 0x6690
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3f4ea
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6120
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42599
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x425cb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
jmp 0x425cb
jmp 0x425c8
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x425de
movq (%r15), %rsi
incq %rsi
callq 0x6380
movq %r14, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x38(%rdi), %rax
movb $0x1, 0x9(%rax)
movq 0x28(%rdi), %rbp
subq 0x20(%rdi), %rbp
shrq $0x3, %rbp
testl %ebp, %ebp
jle 0x44e97
movq %rdi, %rbx
leaq 0xa0(%rdi), %rax
movq %rax, 0x38(%rsp)
cvtsi2ss %ebp, %xmm0
movss %xmm0, 0x4(%rsp)
leaq 0xb8(%rdi), %rax
movq %rax, 0x30(%rsp)
leaq 0xd0(%rdi), %rax
movq %rax, 0x28(%rsp)
leaq 0x70(%rdi), %r13
leaq 0x88(%rdi), %rax
movq %rax, 0x20(%rsp)
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
leaq 0x3(%rsp), %r12
xorps %xmm0, %xmm0
cvtsi2ss %r15d, %xmm0
divss 0x4(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
movq 0xa8(%rbx), %rsi
cmpq 0xb0(%rbx), %rsi
je 0x44d75
movss %xmm0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xa8(%rbx)
jmp 0x44d82
movq 0x38(%rsp), %rdi
movq %r14, %rdx
callq 0x38796
movl $0x0, 0x8(%rsp)
movq 0xc0(%rbx), %rsi
cmpq 0xc8(%rbx), %rsi
je 0x44dad
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xc0(%rbx)
jmp 0x44dba
movq 0x30(%rsp), %rdi
movq %r14, %rdx
callq 0x23392
movq 0xb8(%rbx), %rax
xorps %xmm0, %xmm0
cvtsi2ssl (%rax,%r15,4), %xmm0
movq 0xa0(%rbx), %rax
addss (%rax,%r15,4), %xmm0
movss %xmm0, 0x8(%rsp)
movq 0xd8(%rbx), %rsi
cmpq 0xe0(%rbx), %rsi
je 0x44dfe
movss %xmm0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xd8(%rbx)
jmp 0x44e0b
movq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0x38796
movq 0x20(%rbx), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movl $0x1, %edx
movq %r14, %rdi
leaq 0x40(%rsp), %rsi
movq %r12, %rcx
callq 0xb484
movq %r13, %rdi
movq %r14, %rsi
callq 0x18c56
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x44e53
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movl $0x0, 0x8(%rsp)
movq 0x90(%rbx), %rsi
cmpq 0x98(%rbx), %rsi
je 0x44e7e
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x90(%rbx)
jmp 0x44e8b
movq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x23392
incq %r15
cmpq %r15, %rbp
jne 0x44d40
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x44ec0
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/solver/winpibt.cpp
// Function: winPIBT::checkValidPath(int, std::vector<Node*, std::allocator<Node*>>&, int, int)
bool winPIBT::checkValidPath(int id, Nodes &path, int t1, int t2) {
  int k;
  Node *v1, *v2;

  for (int j = 1; j < path.size(); ++j) {
    v1 = path[j-1];
    v2 = path[j];
    for (int i = 0; i < A.size(); ++i) {
      if (id == i) continue;

      k = ell(i);
      for (int _t = j + t1 + 1; _t <= t2; ++_t) {
        if (k < _t) break;
        if (PATHS[i][_t] == v2) {  // vertex collision
          return false;
        }
      }

      if (PATHS[i].size() - 1 < j + t1) continue;
      if (PATHS[i][j + t1] == v2) {  // collision
        return false;
      }
      if (v1 == PATHS[i][j + t1] && v2 == PATHS[i][j + t1 - 1]) {
        return false;
      }

    }
  }

  return true;
}

// Assembly:
movq (%rdx), %r9
movq 0x8(%rdx), %rdx
subq %r9, %rdx
sarq $0x3, %rdx
movb $0x1, %al
cmpq $0x2, %rdx
jb 0x46885
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x20(%rdi), %r10
movq 0x28(%rdi), %r11
movq %r11, %rbx
subq %r10, %rbx
sarq $0x3, %rbx
movq 0x88(%rdi), %r14
movq 0x70(%rdi), %r13
cmpq $0x1, %rbx
adcq $0x0, %rbx
movl %esi, %esi
movslq %ecx, %rdi
movq %rdi, -0x8(%rsp)
movl $0x1, %r12d
xorl %edi, %edi
movq %r10, -0x28(%rsp)
movq %r11, -0x30(%rsp)
movq %r9, -0x18(%rsp)
movq %rsi, -0x20(%rsp)
movq %rdi, -0x50(%rsp)
incl %ecx
cmpq %r10, %r11
je 0x4685a
movslq %ecx, %rbp
movq -0x8(%r9,%r12,8), %rdi
movq %rdi, -0x38(%rsp)
movq (%r9,%r12,8), %r15
movq -0x8(%rsp), %rdi
addq %r12, %rdi
movq %rdi, -0x48(%rsp)
xorl %edi, %edi
movl %ecx, -0x3c(%rsp)
movq %rbp, -0x10(%rsp)
cmpq %rsi, %rdi
je 0x4684e
movq %r14, %rcx
movl (%r14,%rdi,4), %r10d
cmpl %r10d, %r8d
movl %r8d, %r9d
cmovll %r8d, %r10d
leaq (%rdi,%rdi,2), %r11
movq %r13, %rsi
leaq (,%r11,8), %r11
addq %r13, %r11
movslq %r10d, %r10
cmpq %r10, %rbp
jge 0x467f9
leaq 0x1(%rbp), %r14
movq (%r11), %r13
cmpq %r15, 0x8(%r13,%rbp,8)
movq %r14, %rbp
jne 0x467e1
jmp 0x46876
movq (%r11), %r10
movq 0x8(%r11), %r11
subq %r10, %r11
sarq $0x3, %r11
decq %r11
cmpq -0x48(%rsp), %r11
movq %rcx, %r14
movl %r9d, %r8d
movq -0x18(%rsp), %r9
movq %rsi, %r13
movl -0x3c(%rsp), %ecx
movq -0x20(%rsp), %rsi
movq -0x10(%rsp), %rbp
jb 0x4684e
movq -0x48(%rsp), %r11
movq (%r10,%r11,8), %r11
cmpq %r15, %r11
je 0x46876
cmpq %r11, -0x38(%rsp)
jne 0x4684e
movq -0x48(%rsp), %r11
cmpq -0x8(%r10,%r11,8), %r15
je 0x46876
incq %rdi
cmpq %rbx, %rdi
jne 0x467b2
incq %r12
cmpq %r12, %rdx
setbe %dil
movq -0x28(%rsp), %r10
movq -0x30(%rsp), %r11
jne 0x46779
jmp 0x4687b
movq -0x50(%rsp), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x10(%rdi), %r14
movl 0x1b77c(%rip), %eax     # 0x6280c
movl %eax, 0x30(%rdi)
incl %eax
movl %eax, 0x1b771(%rip)     # 0x6280c
movq $0x0, 0x34(%rdi)
xorl %esi, %esi
callq 0x1c5cc
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x470cc
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73d1
movq %r15, %rdi
callq 0x6620
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x10(%rdi), %r14
movl 0x1b6d6(%rip), %ecx     # 0x6280c
movl %ecx, 0x30(%rdi)
incl %ecx
movl %ecx, 0x1b6cb(%rip)     # 0x6280c
movl %edx, 0x34(%rdi)
movl $0x0, 0x38(%rdi)
xorl %esi, %esi
movq %rax, %rdx
callq 0x1c5cc
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x47177
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
movq %r14, %rsi
callq 0x73ea
movq %r15, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
leaq -0x40(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1110
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1437
movq 0x8(%rbx), %rdi
cmpq 0x10(%rbx), %rdi
jne 0x1416
movq %rbx, %rdi
callq 0x193c
movq 0x8(%rbx), %rdi
leaq 0x20(%rdi), %rax
movq %rax, 0x8(%rbx)
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq %rsi, %rdx
callq 0x189e
jmp 0x13e7
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x144c
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x10f0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x1474
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x10f0
movq %rbx, %rdi
callq 0x1832
movq %r14, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq (%rdi), %rcx
movq %rax, %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
cmpq %rcx, %rax
movl $0x2, %r14d
cmovneq %rdx, %r14
leaq 0x2760(%rip), %rdi      # 0x40d2
movq %r14, %rsi
xorl %edx, %edx
callq 0x1a64
movq %rax, %r15
movq (%rbx), %rdi
movq 0x8(%rbx), %r13
cmpq %rdi, %r13
je 0x19fb
addq $0x10, %rdi
leaq 0x10(%r15), %r12
xorl %eax, %eax
movq %rdi, %rcx
movq %r12, -0x10(%r12)
movq -0x10(%rcx), %rdx
cmpq %rdx, %rcx
je 0x19b4
movq %rdx, -0x10(%r12)
movq (%rcx), %rdx
movq %rdx, (%r12)
jmp 0x19bc
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq -0x8(%rcx), %rdx
movq %rdx, -0x8(%r12)
movq %rcx, -0x10(%rcx)
movq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
incq %rax
movq (%rbx), %rdi
movq 0x8(%rbx), %r13
movq %r13, %rdx
subq %rdi, %rdx
sarq $0x5, %rdx
addq $0x20, %rcx
addq $0x20, %r12
cmpq %rdx, %rax
jne 0x1998
addq $-0x10, %r12
jmp 0x19fe
movq %r15, %r12
cmpq %rdi, %r13
je 0x1a32
addq $-0x10, %r13
movq -0x10(%r13), %rax
cmpq %rax, %r13
je 0x1a22
movq (%r13), %rsi
incq %rsi
movq %rax, %rdi
callq 0x10f0
movq (%rbx), %rdi
leaq -0x20(%r13), %rax
addq $-0x10, %r13
cmpq %rdi, %r13
movq %rax, %r13
jne 0x1a07
testq %rdi, %rdi
je 0x1a43
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x10f0
movq %r15, (%rbx)
movq %r12, 0x8(%rbx)
shlq $0x5, %r14
addq %r14, %r15
movq %r15, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x15cb(%rip), %rsi      # 0x82f6
leaq 0x174d(%rip), %rdx      # 0x847f
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x71da
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
xorl %ebx, %ebx
cmpq $0x0, 0x8(%r14)
je 0x6e04
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
movl $0x20, %edx
callq 0x3210
movl %eax, %ebp
testl %eax, %eax
je 0x6d90
movq 0x4275(%rip), %rdi      # 0xaff0
leaq 0x1742(%rip), %rsi      # 0x84c4
movl $0x15, %edx
callq 0x2150
movl %ebp, %ebx
jmp 0x6e04
movq (%rsp), %rbp
movq 0x8(%rsp), %r13
cmpq %r13, %rbp
je 0x6e04
movq 0x422b(%rip), %r14      # 0xafd0
leaq 0x16d4(%rip), %r15      # 0x8480
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
movq %r14, %rdi
callq 0x2150
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2110
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movl $0x43, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2150
addq $0x20, %rbp
cmpq %r13, %rbp
jne 0x6dac
leaq 0x28(%rsp), %r15
movq %rsp, %rdi
callq 0x6ece
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x6e23
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2130
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6e36
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6ece
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x6e5d
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2130
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rdi, %r14
addq $0x8, %rdi
callq 0x3f54
movq %rax, %r15
addq $0x10, %r14
cmpq %r14, %rax
je 0x3844
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x40(%r15), %rsi
movq 0x48(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3cd2
jmp 0x3865
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x47fb(%rip), %rsi      # 0x804f
leaq 0x47f6(%rip), %rdx      # 0x8051
leaq 0x8(%rsp), %rdi
callq 0x3e6c
xorl %edx, %edx
cmpq %r14, %r15
setne %dl
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3f02
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3897
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq (%rbx), %rax
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38c0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rax
jmp 0x38dc
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38f0
movq (%rax), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movb $0x1, 0x7(%rsp)
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x3f54
addq $0x10, %r12
cmpq %r12, %rax
jne 0x3928
movb $0x0, 0x7(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3f9a
movq %r14, %rdi
movq %rax, %rsi
callq 0x404e
movq (%rbx), %rax
leaq 0x7(%rsp), %rsi
movq %rbx, %rdi
callq *0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x66e4(%rip), %rax      # 0xbcc0
movq %rax, (%rdi)
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
addq $0x38, %rdi
xorl %esi, %esi
callq 0x3350
testl %eax, %eax
jne 0x5621
leaq 0x60(%rbx), %rdi
xorl %esi, %esi
callq 0x32e0
testl %eax, %eax
jne 0x563f
movb $0x0, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x3100
movq %rax, %r14
leaq 0x2be5(%rip), %rsi      # 0x821a
movq %rax, %rdi
callq 0x30c0
jmp 0x565b
movl $0x10, %edi
callq 0x3100
movq %rax, %r14
leaq 0x2be3(%rip), %rsi      # 0x8236
movq %rax, %rdi
callq 0x30c0
movq 0x698e(%rip), %rsi      # 0xbff0
movq 0x694f(%rip), %rdx      # 0xbfb8
movq %r14, %rdi
callq 0x33c0
jmp 0x5673
movq %rax, %r15
movq %r14, %rdi
callq 0x31c0
jmp 0x5683
movq %rax, %r15
movq 0x8(%rbx), %rdi
cmpq %r12, %rdi
je 0x5698
movq (%r12), %rsi
incq %rsi
callq 0x3280
movq %r15, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/dustin[P]kvtest/./callbacks.hh
// Function: kvtest::RememberingCallback<bool>::waitForValue()
void waitForValue() {
            LockHolder lh(&mutex);
            if (!fired) {
                if(pthread_cond_wait(&cond, &mutex) != 0) {
                    throw std::runtime_error("Failed to wait for condition.");
                }
            }
            assert(fired);
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x5c1e
movb 0x9(%rbx), %al
testb %al, %al
jne 0x5533
leaq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0x3360
testl %eax, %eax
jne 0x556f
movb 0x9(%rbx), %al
testb $0x1, %al
je 0x5550
cmpb $0x0, 0x10(%rsp)
jne 0x5548
movq 0x8(%rsp), %rdi
callq 0x31e0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x2b2d(%rip), %rdi      # 0x8084
leaq 0x2d32(%rip), %rsi      # 0x8290
leaq 0x2d3a(%rip), %rcx      # 0x829f
movl $0x4d, %edx
callq 0x3160
movl $0x10, %edi
callq 0x3100
movq %rax, %r14
leaq 0x2cef(%rip), %rsi      # 0x8272
movq %rax, %rdi
callq 0x30c0
movq 0x6a5e(%rip), %rsi      # 0xbff0
movq 0x6a1f(%rip), %rdx      # 0xbfb8
movq %r14, %rdi
callq 0x33c0
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
jmp 0x55b1
movq %rax, %rbx
cmpb $0x0, 0x10(%rsp)
jne 0x55c2
movq 0x8(%rsp), %rdi
callq 0x31e0
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/dustin[P]kvtest/./locks.hh
// Function: kvtest::LockHolder::LockHolder(pthread_mutex_t*)
LockHolder(pthread_mutex_t *m) {
            mutex = m;
            if(pthread_mutex_lock(mutex) != 0) {
                throw std::runtime_error("Failed to acquire lock.");
            }
            unlocked = false;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rsi, %rdi
callq 0x3340
testl %eax, %eax
jne 0x5c40
movb $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x257a(%rip), %rsi      # 0x81ce
movq %rax, %rdi
callq 0x30c0
movq 0x638d(%rip), %rsi      # 0xbff0
movq 0x634e(%rip), %rdx      # 0xbfb8
movq %rbx, %rdi
callq 0x33c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/dustin[P]kvtest/./callbacks.hh
// Function: kvtest::RememberingCallback<kvtest::GetValue>::callback(kvtest::GetValue&)
void callback(T &value) {
            LockHolder lh(&mutex);
            val = value;
            fired = true;
            if(pthread_cond_broadcast(&cond) != 0) {
                throw std::runtime_error("Failed to broadcast change.");
            }
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rdi), %rsi
leaq 0x8(%rsp), %rdi
callq 0x5c1e
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x3130
movb 0x20(%r14), %al
movb %al, 0x28(%rbx)
movb $0x1, 0x30(%rbx)
addq $0x60, %rbx
movq %rbx, %rdi
callq 0x30a0
testl %eax, %eax
jne 0x5dd1
cmpb $0x0, 0x10(%rsp)
jne 0x5dc9
movq 0x8(%rsp), %rdi
callq 0x31e0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x3100
movq %rax, %r14
leaq 0x2471(%rip), %rsi      # 0x8256
movq %rax, %rdi
callq 0x30c0
movq 0x61fc(%rip), %rsi      # 0xbff0
movq 0x61bd(%rip), %rdx      # 0xbfb8
movq %r14, %rdi
callq 0x33c0
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
jmp 0x5e13
movq %rax, %rbx
cmpb $0x0, 0x10(%rsp)
jne 0x5e24
movq 0x8(%rsp), %rdi
callq 0x31e0
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O3/dustin[P]kvtest/suite.cc
// Function: kvtest::TestSuite::initTests()
void TestSuite::initTests() {
    const char *req = getenv("KVTEST_SUITE");
    if (req == NULL || (strcmp(req, "full") == 0)) {
        addTest(new TestTest());
        addTest(new WriteTest());
    } else if (strcmp(req, "test") == 0) {
        addTest(new TestTest());
    } else if (strcmp(req, "endurance") == 0) {
        addTest(new EnduranceTest());
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x25af(%rip), %rdi      # 0x843a
callq 0x32f0
testq %rax, %rax
je 0x5ef2
movq %rax, %r14
leaq 0x25a8(%rip), %rsi      # 0x8447
movq %rax, %rdi
callq 0x3320
testl %eax, %eax
je 0x5ef2
leaq 0x2363(%rip), %rsi      # 0x8215
movq %r14, %rdi
callq 0x3320
testl %eax, %eax
je 0x5f68
leaq 0x2583(%rip), %rsi      # 0x844c
movq %r14, %rdi
callq 0x3320
testl %eax, %eax
jne 0x5fa7
movl $0x8, %edi
callq 0x3270
movq %rax, %r14
leaq 0x5c83(%rip), %rax      # 0xbb70
jmp 0x5f7c
movl $0x8, %edi
callq 0x3270
movq %rax, %r15
leaq 0x5bda(%rip), %rax      # 0xbae0
addq $0x10, %rax
movq %rax, (%r15)
leaq 0x8(%rbx), %r14
movl $0x18, %edi
callq 0x3270
movq %r15, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3060
incq 0x18(%rbx)
addq $0x18, %rbx
movl $0x8, %edi
callq 0x3270
movq %rax, %r15
leaq 0x5be2(%rip), %rax      # 0xbb28
addq $0x10, %rax
movq %rax, (%r15)
movl $0x18, %edi
callq 0x3270
movq %r15, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3060
jmp 0x5fa4
movl $0x8, %edi
callq 0x3270
movq %rax, %r14
leaq 0x5b64(%rip), %rax      # 0xbae0
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x8(%rbx), %r15
movl $0x18, %edi
callq 0x3270
movq %r14, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x3060
addq $0x18, %rbx
incq (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/dustin[P]kvtest/suite.cc
// Function: kvtest::TestSuite::run()
bool TestSuite::run() {
    std::list<Test*>::iterator it;
    bool success = true;
    for (it=tests.begin() ; it != tests.end(); it++ ) {
        success = false;
        Test *t = *it;
        std::cout << "Running test ``" << *t << "'' ";
        try {
            tut->reset();
            t->run(tut);
            std::cout << "PASS" << std::endl;
            success = true;
        } catch(AssertionError &e) {
            std::cout << "FAIL: " << e.what() << std::endl;
        } catch(std::runtime_error &e) {
            std::cout << "EXCEPTION: " << e.what() << std::endl;
        } catch(...) {
            std::cout << "EXCEPTION (unknown)" << std::endl;
        }
    }
    return success;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x8(%rdi), %r15
movq 0x8(%rdi), %r12
cmpq %r15, %r12
je 0x61a8
movq %rdi, %rbx
movq 0x5f70(%rip), %r14      # 0xbfc8
leaq 0x240b(%rip), %r13      # 0x846a
movq 0x10(%r12), %rbp
movl $0xf, %edx
movq %r14, %rdi
leaq 0x23e3(%rip), %rsi      # 0x8456
callq 0x32a0
movq %r14, %rdi
movq %rbp, %rsi
callq 0x61e8
movl $0x3, %edx
movq %rax, %rdi
leaq 0x23d4(%rip), %rsi      # 0x8466
callq 0x32a0
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rsi
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x10(%rax)
movl $0x4, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x32a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3250
movsbl %al, %esi
movq %r14, %rdi
callq 0x3040
movb $0x1, %bpl
movq %rax, %rdi
callq 0x3180
movq (%r12), %r12
cmpq %r15, %r12
jne 0x605f
jmp 0x61ab
movq %rdx, %rbp
movq %rax, %rdi
cmpl $0x3, %ebp
jne 0x613f
callq 0x30d0
movq %rax, %rbp
movl $0x6, %edx
movq %r14, %rdi
leaq 0x2374(%rip), %rsi      # 0x848f
callq 0x32a0
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x3260
movq %rax, %rdi
callq 0x30f0
jmp 0x619c
callq 0x30d0
movq %rax, (%rsp)
cmpl $0x2, %ebp
jne 0x6180
movl $0xb, %edx
movq %r14, %rdi
leaq 0x2327(%rip), %rsi      # 0x8483
callq 0x32a0
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x3260
movq %rax, %rdi
callq 0x30f0
jmp 0x619c
movl $0x13, %edx
movq %r14, %rdi
leaq 0x22e0(%rip), %rsi      # 0x846f
callq 0x32a0
movq %r14, %rdi
callq 0x30f0
callq 0x33b0
xorl %ebp, %ebp
jmp 0x60e7
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
callq 0x33b0
jmp 0x61d8
movq %rax, %rbx
callq 0x33b0
jmp 0x61d8
movq %rax, %rbx
callq 0x33b0
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x395d
// File: /workspace/github_cpp_makefile_star2_O3/dustin[P]kvtest/values.cc
// Function: kvtest::Values::Values(unsigned long, unsigned long, unsigned long)
Values::Values(size_t n, size_t lower, size_t upper) : values(n) {
        for (int i = 0; i < (int)n; i++) {
            values[i] = generateValue(lower, upper);
        }
        assert(values.size() == n);

        it = values.begin();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x7(%rsp), %rdx
callq 0x63e6
movq $0x0, 0x18(%r14)
movq %rbx, 0x8(%rsp)
testl %ebx, %ebx
jle 0x6594
movq 0x10(%rsp), %rax
subq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x8(%rsp), %rax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, 0x20(%rsp)
xorl %r12d, %r12d
movabsq $0xc9714fbcda3ac11, %rbx # imm = 0xC9714FBCDA3AC11
leaq 0x1ff0(%rip), %r15      # 0x84ef
movq %r14, 0x28(%rsp)
callq 0x3110
movq %rax, %r13
andq 0x30(%rsp), %r13
addq 0x18(%rsp), %r13
jb 0x65bc
cmpq 0x10(%rsp), %r13
ja 0x65db
leaq 0x1(%r13), %rdi
movl $0x1, %esi
callq 0x3170
movq %rax, %rbp
testl %r13d, %r13d
jle 0x657a
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
callq 0x3110
movq %rax, %rcx
mulq %rbx
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0x5, %rax
imulq $0x3d, %rax, %rax
subq %rax, %rcx
movb (%r15,%rcx), %al
movb %al, (%rbp,%r14)
incq %r14
cmpq %r14, %r13
jne 0x6547
movq 0x28(%rsp), %r14
movq (%r14), %rax
movq %rbp, (%rax,%r12,8)
incq %r12
cmpq 0x20(%rsp), %r12
jne 0x6504
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq 0x8(%rsp), %rcx
jne 0x65fa
movq %rax, 0x18(%r14)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1fe7(%rip), %rdi      # 0x85aa
leaq 0x1fa7(%rip), %rsi      # 0x8571
leaq 0x1fe5(%rip), %rcx      # 0x85b6
movl $0x17, %edx
callq 0x3160
leaq 0x2006(%rip), %rdi      # 0x85e8
leaq 0x1f88(%rip), %rsi      # 0x8571
leaq 0x1fc6(%rip), %rcx      # 0x85b6
movl $0x18, %edx
callq 0x3160
leaq 0x1f5d(%rip), %rdi      # 0x855e
leaq 0x1f69(%rip), %rsi      # 0x8571
leaq 0x1f6c(%rip), %rcx      # 0x857b
movl $0x29, %edx
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O3/dustin[P]kvtest/ep.cc
// Function: kvtest::EventuallyPersistentStore::EventuallyPersistentStore(kvtest::KVStore*, unsigned long)
EventuallyPersistentStore::EventuallyPersistentStore(KVStore *t,
                                                         size_t est) {

        pthread_mutex_init(&mutex, NULL);
        pthread_cond_init(&cond, NULL);
        est_size = est;
        towrite = NULL;
        initQueue();
        flusher = new Flusher(this);

        // Run in a thread...
        if(pthread_create(&thread, NULL, launch_flusher_thread, flusher)
           != 0) {
            throw std::runtime_error("Error initializing queue thread");
        }

        underlying = t;
        assert(underlying);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq 0x566c(%rip), %rax      # 0xbd10
movq %rax, (%rdi)
leaq 0x20(%rdi), %rbx
movl $0x30005, %esi          # imm = 0x30005
movl $0xc1, %edx
movq %rbx, %rdi
callq 0x722e
leaq 0x48(%r15), %rdi
xorl %esi, %esi
callq 0x3350
leaq 0x70(%r15), %rdi
xorl %esi, %esi
callq 0x32e0
movq %r12, 0x10(%r15)
movq $0x0, 0xa0(%r15)
movq %r15, %rdi
callq 0x67a2
movl $0x10, %edi
callq 0x3270
movq %r15, (%rax)
movb $0x1, 0x8(%rax)
movq %rax, 0x18(%r15)
leaq 0xa8(%r15), %rdi
leaq 0x119(%rip), %rdx       # 0x6826
xorl %esi, %esi
movq %rax, %rcx
callq 0x3400
testl %eax, %eax
jne 0x6730
movq %r14, 0x8(%r15)
testq %r14, %r14
je 0x6762
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x3100
movq %rax, %r14
leaq 0x1eb0(%rip), %rsi      # 0x85f4
movq %rax, %rdi
callq 0x30c0
movq 0x589d(%rip), %rsi      # 0xbff0
movq 0x585e(%rip), %rdx      # 0xbfb8
movq %r14, %rdi
callq 0x33c0
leaq 0x1eab(%rip), %rdi      # 0x8614
leaq 0x1eaf(%rip), %rsi      # 0x861f
leaq 0x1eae(%rip), %rcx      # 0x8625
movl $0x23, %edx
callq 0x3160
movq %rax, %r15
movq %r14, %rdi
callq 0x31c0
jmp 0x6791
movq %rax, %r15
movq %rbx, %rdi
callq 0x7298
movq %r15, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/dustin[P]kvtest/ep.cc
// Function: kvtest::launch_flusher_thread(void*)
static void* launch_flusher_thread(void* arg) {
        Flusher *flusher = (Flusher*) arg;
        try {
            flusher->run();
        } catch(...) {
            std::cerr << "Caught a fatal exception in the thread" << std::endl;
        }
        return NULL;
    }

// Assembly:
pushq %rbx
callq 0x7774
xorl %eax, %eax
popq %rbx
retq
movq %rax, %rdi
callq 0x30d0
movq 0x57a9(%rip), %rdi      # 0xbfe8
leaq 0x1ed2(%rip), %rsi      # 0x8718
movl $0x26, %edx
callq 0x32a0
movq 0x5791(%rip), %rdi      # 0xbfe8
callq 0x30f0
callq 0x33b0
jmp 0x682c
movq %rax, %rbx
callq 0x33b0
movq %rbx, %rdi
callq 0x33e0
movq %rax, %rdi
callq 0x395d
nop