LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::ADD_DONE_SWAPERS(S*)
void PPS::ADD_DONE_SWAPERS(S* s) {
  doneSwapers.push_back(s);
  Agents agents = s->agents;
  if (agents.size() == 3) {
    Agent* a3 = agents[2];
    isTmpGoals[a3->getId()] = false;
    P->assign(a3->getTask());
    a3->releaseTask();
    a3->setGoal(goals[a3->getId()]);
  }
  for (auto a : agents) {
    if (!inArray(a, pushers)) {
      pushers.push_back(a);
    } else {
      std::cout << "error@PPS::ADD_DONE_SWAPERS, "
                << "duplicated pusher : " << a->getId()
                << "\n";
      std::exit(1);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq 0xd0(%rdi), %rsi
cmpq 0xd8(%rdi), %rsi
je 0x3ba24
movq %rax, (%rsi)
addq $0x8, 0xd0(%rbx)
jmp 0x3ba35
leaq 0xc8(%rbx), %rdi
leaq 0x10(%rsp), %rdx
callq 0x3def0
movq 0x10(%rsp), %rsi
addq $0x8, %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0xb51c
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
cmpq $0x18, %rcx
jne 0x3bacc
movq 0x10(%rax), %r14
movslq (%r14), %rcx
leaq 0x3f(%rcx), %rax
testq %rcx, %rcx
cmovnsq %rcx, %rax
sarq $0x6, %rax
shlq $0x3, %rax
addq 0x160(%rbx), %rax
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
leaq 0x3f(%rdx), %rsi
andq %rcx, %rsi
xorl %edi, %edi
cmpq %rdx, %rsi
setbe %dil
movq $-0x2, %rdx
rolq %cl, %rdx
andq %rdx, -0x8(%rax,%rdi,8)
movq 0x10(%rbx), %rdi
movq 0x18(%r14), %rsi
callq 0x25982
movq %r14, %rdi
callq 0x1934a
movslq (%r14), %rax
movq 0x148(%rbx), %rcx
movq (%rcx,%rax,8), %rax
movq %rax, 0x10(%r14)
movq 0x18(%rsp), %r13
movq 0x20(%rsp), %rbp
cmpq %rbp, %r13
je 0x3bb39
leaq 0x68(%rbx), %r14
leaq 0x30(%rsp), %r15
leaq 0x8(%rsp), %r12
movq (%r13), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x30(%rsp)
movq 0x68(%rbx), %rdi
movq 0x70(%rbx), %rsi
movq %r15, %rdx
callq 0x38b4d
movq 0x70(%rbx), %rsi
cmpq %rsi, %rax
jne 0x3bb5f
cmpq 0x78(%rbx), %rsi
je 0x3bb25
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x70(%rbx)
jmp 0x3bb30
movq %r14, %rdi
movq %r12, %rdx
callq 0x18edc
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x3bae9
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3bb50
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x26442(%rip), %rdi     # 0x61fa8
leaq 0xf8e8(%rip), %rsi      # 0x4b455
movl $0x1d, %edx
callq 0x63f0
movq 0x2642a(%rip), %rdi     # 0x61fa8
leaq 0xf8ee(%rip), %rsi      # 0x4b473
movl $0x14, %edx
callq 0x63f0
movq 0x8(%rsp), %rax
movl (%rax), %esi
movq 0x2640b(%rip), %rdi     # 0x61fa8
callq 0x6610
leaq 0xc9ba(%rip), %rsi      # 0x48563
movq %rax, %rdi
callq 0x6360
movl $0x1, %edi
callq 0x6440
jmp 0x3bbbf
jmp 0x3bbbf
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3bbd9
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
callq 0x6620
nop
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::SHORTEST_PATH(Agent*, Node*)
Nodes PPS::SHORTEST_PATH(Agent* c, Node* g) {
  if (H.empty()) return G->getPath(c->getNode(), g);

  Nodes prohibited;
  for (auto a : H) prohibited.push_back(a->getNode());
  return G->getPath(c->getNode(), g, prohibited);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x128(%rsi), %r14
movq 0x130(%rsi), %rbx
cmpq %rbx, %r14
je 0x3bc88
movq %rcx, 0x20(%rsp)
movq %r13, 0x28(%rsp)
xorps %xmm0, %xmm0
movq %rsp, %r13
movaps %xmm0, (%r13)
movq $0x0, 0x10(%r13)
leaq 0x30(%rsp), %rbp
movq (%r14), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1fc22
addq $0x8, %r14
cmpq %rbx, %r14
jne 0x3bc2e
movq 0x38(%r12), %rsi
movq 0x8(%r15), %rdx
movq (%rsi), %rax
movq %rsp, %r8
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
movq 0x20(%rsp), %rcx
callq *0x20(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3bc83
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rax
jmp 0x3bc9d
movq 0x38(%r12), %rsi
movq 0x8(%r15), %rdx
movq (%rsi), %rax
movq %r13, %rdi
callq *0x18(%rax)
movq %r13, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3bcae
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3bcc7
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
callq 0x6620
nop
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::FINISH_SWAP(S*)
void PPS::FINISH_SWAP(S* s) {
  // error check
  if (s->agents.size() != 2) {
    std::cout << "error@PPS::FINISH_SWAP, the number of agetns is not two" << "\n";
    std::exit(1);
  }

  // clear L
  auto itrL = std::find(L.begin(), L.end(), s->target);
  L.erase(itrL);
  itrL = std::find(L.begin(), L.end(), s->origin);
  L.erase(itrL);
  itrL = std::find(L.begin(), L.end(), s->evacH);
  L.erase(itrL);
  itrL = std::find(L.begin(), L.end(), s->evacL);
  L.erase(itrL);

  swaperToPusher.push_back(s->agents[0]);
  swaperToPusher.push_back(s->agents[1]);
  doneSwapers.push_back(s);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
movq 0x10(%rsi), %rax
subq 0x8(%rsi), %rax
cmpq $0x10, %rax
jne 0x3d009
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x110(%rdi), %rdi
movq 0x118(%rbx), %rsi
addq $0x40, %rdx
callq 0x19ae8
leaq 0x8(%rax), %rsi
movq 0x118(%rbx), %rdx
cmpq %rdx, %rsi
je 0x3ce98
subq %rsi, %rdx
movq %rax, %rdi
callq 0x65b0
movq 0x110(%rbx), %rdi
movq 0x118(%rbx), %rsi
addq $-0x8, %rsi
movq %rsi, 0x118(%rbx)
movq (%rsp), %rdx
addq $0x48, %rdx
callq 0x19ae8
leaq 0x8(%rax), %rsi
movq 0x118(%rbx), %rdx
cmpq %rdx, %rsi
je 0x3ced9
subq %rsi, %rdx
movq %rax, %rdi
callq 0x65b0
movq 0x110(%rbx), %rdi
movq 0x118(%rbx), %rsi
addq $-0x8, %rsi
movq %rsi, 0x118(%rbx)
movq (%rsp), %rdx
addq $0x50, %rdx
callq 0x19ae8
leaq 0x8(%rax), %rsi
movq 0x118(%rbx), %rdx
cmpq %rdx, %rsi
je 0x3cf1a
subq %rsi, %rdx
movq %rax, %rdi
callq 0x65b0
movq 0x110(%rbx), %rdi
movq 0x118(%rbx), %rsi
addq $-0x8, %rsi
movq %rsi, 0x118(%rbx)
movq (%rsp), %rdx
addq $0x58, %rdx
callq 0x19ae8
leaq 0x8(%rax), %rsi
movq 0x118(%rbx), %rdx
cmpq %rdx, %rsi
je 0x3cf5b
subq %rsi, %rdx
movq %rax, %rdi
callq 0x65b0
addq $-0x8, 0x118(%rbx)
leaq 0xb0(%rbx), %r14
movq (%rsp), %rax
movq 0x8(%rax), %rdx
movq 0xb8(%rbx), %rsi
cmpq 0xc0(%rbx), %rsi
je 0x3cf92
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0xb8(%rbx)
jmp 0x3cf9a
movq %r14, %rdi
callq 0x18edc
movq (%rsp), %rax
movq 0x8(%rax), %rdx
addq $0x8, %rdx
movq 0xb8(%rbx), %rsi
cmpq 0xc0(%rbx), %rsi
je 0x3cfc6
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0xb8(%rbx)
jmp 0x3cfce
movq %r14, %rdi
callq 0x18edc
movq 0xd0(%rbx), %rsi
cmpq 0xd8(%rbx), %rsi
je 0x3cfef
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0xd0(%rbx)
jmp 0x3d001
addq $0xc8, %rbx
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x3def0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x24f98(%rip), %rdi     # 0x61fa8
leaq 0xe5ee(%rip), %rsi      # 0x4b605
callq 0x6360
leaq 0xb540(%rip), %rsi      # 0x48563
movq %rax, %rdi
callq 0x6360
movl $0x1, %edi
callq 0x6440
nop
// File: /workspace/github_cpp_makefile_star2_O1/Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::getSortedEsv(Agent*)
Nodes PPS::getSortedEsv(Agent* c) {
  Nodes lst = deg3nodes;
  Graph* _G = G;
  Node* v = c->getNode();
  // actually, should use pathDist, but for fast implementation
  std::sort(lst.begin(), lst.end(),
            [_G, v] (Node* v1, Node* v2)
            { return _G->dist(v, v1) < _G->dist(v, v2); });
  return lst;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
addq $0x188, %rsi            # imm = 0x188
callq 0x19a68
movq (%rbx), %r13
movq 0x8(%rbx), %r14
cmpq %r14, %r13
je 0x3d0e1
movq 0x38(%r15), %r15
movq 0x8(%r12), %r12
movq %r14, %rbp
subq %r13, %rbp
movq %rbp, %rax
sarq $0x3, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rcx
movq %r12, %r8
callq 0x3d2ba
cmpq $0x81, %rbp
jl 0x3d0d0
leaq 0x80(%r13), %rbp
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x3d77f
cmpq %r14, %rbp
je 0x3d0e1
movq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3d847
addq $0x8, %rbp
jmp 0x3d0b7
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x3d77f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3d0f5
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3d10c
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x6380
movq %r14, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O1/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), %rcx
movq 0x28(%rdi), %rax
movq %rax, %rdx
subq %rcx, %rdx
movq %rdx, %rdi
sarq $0x5, %rdi
testq %rdi, %rdi
jle 0x3d17d
andq $-0x20, %rdx
addq %rcx, %rdx
incq %rdi
addq $0x10, %rcx
movq %rcx, %r14
movq -0x10(%r14), %rcx
cmpq %rsi, 0x8(%rcx)
je 0x3d1c6
movq -0x8(%r14), %rcx
cmpq %rsi, 0x8(%rcx)
je 0x3d1cc
movq (%r14), %rcx
cmpq %rsi, 0x8(%rcx)
je 0x3d1d6
movq 0x8(%r14), %rcx
cmpq %rsi, 0x8(%rcx)
je 0x3d1d2
decq %rdi
addq $0x20, %r14
cmpq $0x1, %rdi
jg 0x3d146
movq %rdx, %rcx
movq %rax, %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq $0x1, %rdx
je 0x3d1b6
cmpq $0x2, %rdx
je 0x3d1a9
movq %rax, %r14
cmpq $0x3, %rdx
jne 0x3d1d6
movq (%rcx), %rdx
cmpq %rsi, 0x8(%rdx)
je 0x3d1c1
addq $0x8, %rcx
movq (%rcx), %rdx
cmpq %rsi, 0x8(%rdx)
je 0x3d1c1
addq $0x8, %rcx
movq (%rcx), %rdx
cmpq %rsi, 0x8(%rdx)
cmovneq %rax, %rcx
movq %rcx, %r14
jmp 0x3d1d6
addq $-0x10, %r14
jmp 0x3d1d6
addq $-0x8, %r14
jmp 0x3d1d6
addq $0x8, %r14
xorq %rax, %r14
movq %rsp, %rdx
movq %rsi, (%rdx)
movq 0x110(%rbx), %rdi
movq 0x118(%rbx), %rsi
callq 0x19ae8
xorq 0x118(%rbx), %rax
orq %r14, %rax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe4cc(%rip), %rsi      # 0x4b6fd
callq 0x6690
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3f790
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6120
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d26d
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 0x3d29f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
jmp 0x3d29f
jmp 0x3d29c
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3d2b2
movq (%r15), %rsi
incq %rsi
callq 0x6380
movq %r14, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb51c
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x2b622
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3e6a6
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 0x3e6ee
addq $0x40, %rbx
leaq 0x10(%rsp), %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x3fe27
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0xc125(%rip), %rdi      # 0x4a81a
leaq 0xc1b3(%rip), %rsi      # 0x4a8af
leaq 0xd165(%rip), %rcx      # 0x4b868
movl $0x4a, %edx
callq 0x6260
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3f094
movq (%rbx), %rcx
cmpq %rcx, 0x8(%rbx)
je 0x3f238
movslq %eax, %r15
xorl %r12d, %r12d
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
movq %rsp, %r14
leaq (,%r12,8), %rax
leaq (%rax,%rax,2), %rax
movq 0x8(%rcx,%rax), %rcx
movq -0x8(%rcx), %rcx
movq %rcx, (%rsp)
movq (%rbx), %rcx
movq 0x8(%rcx,%rax), %rsi
movq %rsi, %rdx
subq (%rcx,%rax), %rdx
sarq $0x3, %rdx
cmpq %r15, %rdx
je 0x3f21a
leaq (%rcx,%rax), %rdi
addq %rcx, %rax
addq $0x8, %rax
leaq (%r12,%r12,2), %rbp
cmpq 0x10(%rdi), %rsi
je 0x3f1f0
movq (%rsp), %rcx
movq %rcx, (%rsi)
addq $0x8, (%rax)
jmp 0x3f1f8
movq %r14, %rdx
callq 0x1c69a
movq (%rbx), %rax
leaq (%rax,%rbp,8), %rdi
leaq (%rax,%rbp,8), %rax
addq $0x8, %rax
movq (%rax), %rsi
movq %rsi, %rcx
subq -0x8(%rax), %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
jne 0x3f1dd
incq %r12
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
sarq $0x3, %rax
imulq %r13, %rax
cmpq %r12, %rax
ja 0x3f19d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8fbc(%rip), %rdx      # 0x48564
movq %rdx, %rsi
callq 0xb860
movl %r15d, %ebp
negl %ebp
cmovsl %r15d, %ebp
movl $0x1, %r12d
cmpl $0xa, %ebp
jb 0x3f60d
movl $0x4, %r12d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x3f604
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x3f60a
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x3f60d
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r12d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x3f5d1
addl $-0x3, %r12d
jmp 0x3f60d
addl $-0x2, %r12d
jmp 0x3f60d
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 0xb762
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6120
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3f663
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
leaq 0xc78d(%rip), %rsi      # 0x4bdf7
movq %rbx, %rdi
callq 0x6690
movl (%r14), %r14d
movl %r14d, %ebp
negl %ebp
cmovsl %r14d, %ebp
movl $0x1, %r15d
cmpl $0xa, %ebp
jb 0x3f6d2
movl $0x4, %r15d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x3f6c9
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x3f6cf
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x3f6d2
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r15d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x3f696
addl $-0x3, %r15d
jmp 0x3f6d2
addl $-0x2, %r15d
jmp 0x3f6d2
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 0xb762
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6120
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3f722
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 0x3f73a
jmp 0x3f755
jmp 0x3f755
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3f758
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
jmp 0x3f758
movq %rax, %r14
movq (%rbx), %rdi
cmpq 0x20(%rsp), %rdi
je 0x3f772
movq 0x20(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x6380
movq %r14, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40132
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 0xb44a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18be6
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x40129
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x400e7
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 0x4015b
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
callq 0x6620
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x402b8
incl 0x68(%rbx)
movq %rbx, %rdi
callq 0x402ca
cmpb $0x1, 0xa0(%rbx)
jne 0x402b6
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rbx), %rax
movl 0x8(%rax), %ecx
cmpl 0xc(%rax), %ecx
jl 0x40279
jmp 0x402b8
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_O1/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 $0x60, %rsp
movl %edx, %r15d
movq %rdi, %rbx
leaq 0x40(%rsp), %r12
movq %rsi, (%r12)
movq 0x20(%rdi), %rdi
movq 0x28(%rbx), %rsi
movq %r12, %rdx
callq 0x38b4d
movq %rax, %r14
subq 0x20(%rbx), %r14
movq (%r12), %rax
movq 0x18(%rax), %rsi
leaq 0x48(%rsp), %r13
movq %r13, %rdi
callq 0x19a68
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 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
callq 0xb44a
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq $0x1, %rcx
je 0x40a44
cmpq $0x2, %rcx
jne 0x40ac4
movq 0x40(%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 0x41164
addq $0x10, %rsp
jmp 0x40a71
movq 0x40(%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 0x41c8e
addq $0x10, %rsp
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
testq %rdi, %rdi
je 0x40aad
subq %rdi, %rsi
callq 0x6380
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x40ac4
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 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
addq $0x8, %rdx
callq 0x42a62
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x40b08
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x40b1f
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x40b31
jmp 0x40b31
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x40b50
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
jmp 0x40b50
movq %rax, %rbx
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x40b67
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
callq 0x6620
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9610(%rip), %rsi      # 0x4bdcf
callq 0x6690
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3f790
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6120
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x427fb
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 0x4282d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
jmp 0x4282d
jmp 0x4282a
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x42840
movq (%r15), %rsi
incq %rsi
callq 0x6380
movq %r14, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4521b
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 0x450f9
movss %xmm0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xa8(%rbx)
jmp 0x45106
movq 0x38(%rsp), %rdi
movq %r14, %rdx
callq 0x38a0e
movl $0x0, 0x8(%rsp)
movq 0xc0(%rbx), %rsi
cmpq 0xc8(%rbx), %rsi
je 0x45131
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xc0(%rbx)
jmp 0x4513e
movq 0x30(%rsp), %rdi
movq %r14, %rdx
callq 0x233f8
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 0x45182
movss %xmm0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xd8(%rbx)
jmp 0x4518f
movq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0x38a0e
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 0xb44a
movq %r13, %rdi
movq %r14, %rsi
callq 0x18be6
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x451d7
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movl $0x0, 0x8(%rsp)
movq 0x90(%rbx), %rsi
cmpq 0x98(%rbx), %rsi
je 0x45202
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x90(%rbx)
jmp 0x4520f
movq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x233f8
incq %r15
cmpq %r15, %rbp
jne 0x450c4
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 0x45244
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x2, %rdx
setb %al
jb 0x46b2f
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), %r15
movq 0x70(%rdi), %rdi
movl %esi, %esi
cmpq $0x1, %rbx
adcq $0x0, %rbx
movslq %ecx, %r14
movq %r14, -0x8(%rsp)
movl $0x1, %r12d
movq %r10, -0x28(%rsp)
movq %r11, -0x30(%rsp)
movq %r9, -0x18(%rsp)
movq %rsi, -0x20(%rsp)
incl %ecx
cmpq %r10, %r11
je 0x46b0c
movslq %ecx, %r13
movq -0x8(%r9,%r12,8), %r10
movq %r10, -0x38(%rsp)
movq (%r9,%r12,8), %rbp
movq -0x8(%rsp), %r10
addq %r12, %r10
movq %r10, -0x48(%rsp)
xorl %r14d, %r14d
movl %ecx, -0x3c(%rsp)
movq %r13, -0x10(%rsp)
cmpq %rsi, %r14
je 0x46b00
movq %r15, %rcx
movl (%r15,%r14,4), %r15d
cmpl %r15d, %r8d
movl %r8d, %r9d
cmovll %r8d, %r15d
leaq (%r14,%r14,2), %r11
movq %rdi, %r8
leaq (%rdi,%r11,8), %r10
movslq %r15d, %r15
cmpq %r15, %r13
jge 0x46aa9
leaq 0x1(%r13), %rdi
movq (%r10), %rsi
cmpq %rbp, 0x8(%rsi,%r13,8)
movq %rdi, %r13
jne 0x46a91
jmp 0x46b25
movq %r8, %rdi
movq (%r8,%r11,8), %r10
movq 0x8(%r8,%r11,8), %rsi
subq %r10, %rsi
sarq $0x3, %rsi
decq %rsi
cmpq -0x48(%rsp), %rsi
movq %rcx, %r15
movl %r9d, %r8d
movl -0x3c(%rsp), %ecx
movq -0x18(%rsp), %r9
movq -0x20(%rsp), %rsi
movq -0x10(%rsp), %r13
jb 0x46b00
movq -0x48(%rsp), %r11
movq (%r10,%r11,8), %r11
cmpq %rbp, %r11
je 0x46b25
cmpq %r11, -0x38(%rsp)
jne 0x46b00
movq -0x48(%rsp), %r11
cmpq -0x8(%r10,%r11,8), %rbp
je 0x46b25
incq %r14
cmpq %rbx, %r14
jne 0x46a69
incq %r12
cmpq %r12, %rdx
setbe %al
movq -0x28(%rsp), %r10
movq -0x30(%rsp), %r11
jne 0x46a34
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl 0x1b4bf(%rip), %eax     # 0x6280c
movl %eax, 0x30(%rdi)
incl %eax
movl %eax, 0x1b4b4(%rip)     # 0x6280c
movq $0x0, 0x34(%rdi)
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x47374
movq %rsi, (%rax)
addq $0x8, 0x8(%rbx)
jmp 0x47388
leaq 0x10(%rbx), %r14
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1c69a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x473aa
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7373
movq %r15, %rdi
callq 0x6620
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, 0x8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl 0x1b3ff(%rip), %eax     # 0x6280c
movl %eax, 0x30(%rdi)
incl %eax
movl %eax, 0x1b3f4(%rip)     # 0x6280c
movl %edx, 0x34(%rdi)
movl $0x0, 0x38(%rdi)
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x47436
movq %rsi, (%rax)
addq $0x8, 0x8(%rbx)
jmp 0x4744a
leaq 0x10(%rbx), %r14
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1c69a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x4746c
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
movq %r14, %rsi
callq 0x738c
movq %r15, %rdi
callq 0x6620
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %r12
movq 0x8(%rdi), %rbx
cmpq %rbx, %r12
je 0x1352
leaq -0x38(%rbp), %r13
movq 0x2cdc(%rip), %r14      # 0x3fd0
leaq 0xd0d(%rip), %r15       # 0x2008
movq %r13, -0x48(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x1a24
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r14, %rdi
callq 0x1100
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x1100
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x1349
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x10f0
addq $0x20, %r12
cmpq %rbx, %r12
jne 0x12fb
movq 0x2c77(%rip), %rbx      # 0x3fd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1080
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x13a7
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x10f0
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
cmpq 0x10(%rbx), %rax
jne 0x1412
movq %rbx, %rdi
callq 0x1abe
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 0x1a24
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 0x19ba
movq %r14, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O1/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 0x25de(%rip), %rdi      # 0x40d2
movq %r14, %rsi
xorl %edx, %edx
callq 0x1be4
movq %rax, %r15
movq (%rbx), %rdi
movq 0x8(%rbx), %r13
cmpq %rdi, %r13
je 0x1b7d
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 0x1b36
movq %rdx, -0x10(%r12)
movq (%rcx), %rdx
movq %rdx, (%r12)
jmp 0x1b3e
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 0x1b1a
addq $-0x10, %r12
jmp 0x1b80
movq %r15, %r12
cmpq %rdi, %r13
je 0x1bb1
addq $-0x10, %r13
movq -0x10(%r13), %rdi
cmpq %rdi, %r13
je 0x1b9e
movq (%r13), %rsi
incq %rsi
callq 0x10f0
movq (%rbx), %rdi
leaq -0x20(%r13), %rax
addq $-0x10, %r13
cmpq %rdi, %r13
movq %rax, %r13
jne 0x1b89
testq %rdi, %rdi
je 0x1bc2
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/donqustix[P]SoftwareRenderer/src/main.cpp
// Function: (anonymous namespace)::Matrix<float>::operator*=((anonymous namespace)::Matrix<float> 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
movq %rdi, %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rbp)
movaps %xmm0, -0x20(%rbp)
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
xorl %ecx, %ecx
movq %rdi, %rdx
movq %rcx, %rdi
shlq $0x4, %rdi
addq %rbp, %rdi
addq $-0x40, %rdi
movq %rsi, %r8
xorl %r9d, %r9d
movss (%rdi,%r9,4), %xmm0
xorl %r10d, %r10d
movss (%rdx,%r10), %xmm1
mulss (%r8,%r10,4), %xmm1
addss %xmm1, %xmm0
addq $0x4, %r10
cmpq $0x10, %r10
jne 0x44c2
movss %xmm0, (%rdi,%r9,4)
incq %r9
addq $0x4, %r8
cmpq $0x4, %r9
jne 0x44b9
incq %rcx
addq $0x10, %rdx
cmpq $0x4, %rcx
jne 0x44a5
movaps -0x40(%rbp), %xmm0
movaps -0x30(%rbp), %xmm1
movaps -0x20(%rbp), %xmm2
movaps -0x10(%rbp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rbp)
movss (%rsi), %xmm0
movss 0x4(%rsi), %xmm1
movss 0x8(%rsi), %xmm2
movss 0xc(%rsi), %xmm3
xorl %eax, %eax
movss 0x4(%rdi,%rax,4), %xmm4
mulss %xmm1, %xmm4
movss (%rdi,%rax,4), %xmm5
mulss %xmm0, %xmm5
addss %xmm4, %xmm5
movss 0x8(%rdi,%rax,4), %xmm4
mulss %xmm2, %xmm4
addss %xmm5, %xmm4
movss 0xc(%rdi,%rax,4), %xmm5
mulss %xmm3, %xmm5
addss %xmm4, %xmm5
movss %xmm5, -0x10(%rbp,%rax)
addq $0x4, %rax
cmpq $0x10, %rax
jne 0x46c5
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rdi, %r14
addq $0x8, %rdi
callq 0x3f7a
movq %rax, %r15
addq $0x10, %r14
cmpq %r14, %rax
setne %bpl
leaq 0x10(%rsp), %rax
je 0x3847
movq %rax, -0x10(%rax)
movq 0x40(%r15), %rsi
movq 0x48(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x3d04
jmp 0x3861
movq %rax, -0x10(%rax)
leaq 0x57fd(%rip), %rsi      # 0x904f
leaq 0x57f8(%rip), %rdx      # 0x9051
movq %rsp, %rdi
callq 0x3e98
xorl %edx, %edx
cmpq %r14, %r15
setne %dl
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x3f28
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3891
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3280
movq (%rbx), %rax
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38ba
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3280
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3900
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x3916
jmp 0x3921
movq %rax, %rbx
cmpq %r14, %r15
jne 0x3902
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3900
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3280
xorl %ebp, %ebp
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
setne %cl
testb %cl, %bpl
je 0x3921
movq (%rax), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3f7a
addq $0x10, %r12
cmpq %r12, %rax
jne 0x395a
movb $0x0, 0x7(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3fc0
movq %r14, %rdi
movq %rax, %rsi
callq 0x4068
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_O1/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 0x76b4(%rip), %rax      # 0xccc0
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 0x5651
leaq 0x60(%rbx), %rdi
xorl %esi, %esi
callq 0x32e0
testl %eax, %eax
jne 0x566f
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 0x3bb5(%rip), %rsi      # 0x921a
movq %rax, %rdi
callq 0x30c0
jmp 0x568b
movl $0x10, %edi
callq 0x3100
movq %rax, %r14
leaq 0x3bb3(%rip), %rsi      # 0x9236
movq %rax, %rdi
callq 0x30c0
movq 0x795e(%rip), %rsi      # 0xcff0
movq 0x791f(%rip), %rdx      # 0xcfb8
movq %r14, %rdi
callq 0x33c0
jmp 0x56a3
movq %rax, %r15
movq %r14, %rdi
callq 0x31c0
jmp 0x56b3
movq %rax, %r15
movq 0x8(%rbx), %rdi
cmpq %r12, %rdi
je 0x56c8
movq (%r12), %rsi
incq %rsi
callq 0x3280
movq %r15, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5c64
cmpb $0x0, 0x9(%rbx)
jne 0x5557
leaq 0x38(%rbx), %rdi
movq %r14, %rsi
callq 0x3360
testl %eax, %eax
jne 0x559a
cmpb $0x0, 0x9(%rbx)
je 0x557b
cmpb $0x0, 0x10(%rsp)
jne 0x5573
movq 0x8(%rsp), %rdi
callq 0x31e0
movb $0x1, 0x10(%rsp)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
leaq 0x3b02(%rip), %rdi      # 0x9084
leaq 0x3d07(%rip), %rsi      # 0x9290
leaq 0x3d0f(%rip), %rcx      # 0x929f
movl $0x4d, %edx
callq 0x3160
movl $0x10, %edi
callq 0x3100
movq %rax, %r14
leaq 0x3cc4(%rip), %rsi      # 0x9272
movq %rax, %rdi
callq 0x30c0
movq 0x7a33(%rip), %rsi      # 0xcff0
movq 0x79f4(%rip), %rdx      # 0xcfb8
movq %r14, %rdi
callq 0x33c0
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
jmp 0x55dc
movq %rax, %rbx
cmpb $0x0, 0x10(%rsp)
jne 0x55f2
movq 0x8(%rsp), %rdi
callq 0x31e0
movb $0x1, 0x10(%rsp)
movq %rbx, %rdi
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5c86
movb $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x3100
movq %rax, %rbx
leaq 0x3534(%rip), %rsi      # 0x91ce
movq %rax, %rdi
callq 0x30c0
movq 0x7347(%rip), %rsi      # 0xcff0
movq 0x7308(%rip), %rdx      # 0xcfb8
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_O1/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 0x5c64
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 0x5e26
cmpb $0x0, 0x10(%rsp)
jne 0x5e1e
movq 0x8(%rsp), %rdi
callq 0x31e0
movb $0x1, 0x10(%rsp)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x3100
movq %rax, %r14
leaq 0x341c(%rip), %rsi      # 0x9256
movq %rax, %rdi
callq 0x30c0
movq 0x71a7(%rip), %rsi      # 0xcff0
movq 0x7168(%rip), %rdx      # 0xcfb8
movq %r14, %rdi
callq 0x33c0
movq %rax, %rbx
movq %r14, %rdi
callq 0x31c0
jmp 0x5e68
movq %rax, %rbx
cmpb $0x0, 0x10(%rsp)
jne 0x5e7e
movq 0x8(%rsp), %rdi
callq 0x31e0
movb $0x1, 0x10(%rsp)
movq %rbx, %rdi
callq 0x33e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3553(%rip), %rdi      # 0x943a
callq 0x32f0
testq %rax, %rax
je 0x5f4e
movq %rax, %r14
leaq 0x354c(%rip), %rsi      # 0x9447
movq %rax, %rdi
callq 0x3320
testl %eax, %eax
je 0x5f4e
leaq 0x3307(%rip), %rsi      # 0x9215
movq %r14, %rdi
callq 0x3320
testl %eax, %eax
je 0x5fc4
leaq 0x3527(%rip), %rsi      # 0x944c
movq %r14, %rdi
callq 0x3320
testl %eax, %eax
jne 0x6003
movl $0x8, %edi
callq 0x3270
movq %rax, %r14
leaq 0x6c27(%rip), %rax      # 0xcb70
jmp 0x5fd8
movl $0x8, %edi
callq 0x3270
movq %rax, %r15
leaq 0x6b7e(%rip), %rax      # 0xcae0
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 0x6b86(%rip), %rax      # 0xcb28
addq $0x10, %rax
movq %rax, (%r15)
movl $0x18, %edi
callq 0x3270
movq %r15, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3060
jmp 0x6000
movl $0x8, %edi
callq 0x3270
movq %rax, %r14
leaq 0x6b08(%rip), %rax      # 0xcae0
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