LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Kei18[P]pibt/./src/solver/pibt.cpp
// Function: PIBT::allocate()
void PIBT::allocate() {
  if (P->allocated()) return;
  auto T = P->getT();
  Graph* _G = G;

  for (auto a : A) {
    if (a->hasTask()) continue;
    if (T.empty()) {
      a->releaseGoalOnly();
    } else {
      auto v = a->getNode();
      auto itr = std::min_element(T.begin(), T.end(),
                                  [v, _G] (Task* t1, Task* t2) {
                                    return _G->dist(t1->getG()[0], v)
                                      < _G->dist(t2->getG()[0], v);
                                  });
      a->setGoal((*itr)->getG()[0]);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0x8947a
jmp 0x8947f
jmp 0x89643
movq -0xa8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq -0x20(%rbp), %rdi
callq 0x8bb10
movq -0xa8(%rbp), %rax
movq 0x38(%rax), %rcx
movq %rcx, -0x28(%rbp)
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x39b60
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x399f0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x51bd0
testb $0x1, %al
jne 0x894da
jmp 0x8963a
leaq -0x38(%rbp), %rdi
callq 0x51c10
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x3ae30
movb %al, -0xa9(%rbp)
jmp 0x894fb
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x89507
jmp 0x8951d
jmp 0x8962c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x8964c
leaq -0x20(%rbp), %rdi
callq 0x55570
testb $0x1, %al
jne 0x8952c
jmp 0x8953c
movq -0x48(%rbp), %rdi
callq 0x3a7c0
jmp 0x89537
jmp 0x8962a
movq -0x48(%rbp), %rdi
callq 0x51cb0
movq %rax, -0xb8(%rbp)
jmp 0x8954e
movq -0xb8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x3a140
movq -0xc8(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x39fd0
movq %rax, -0x78(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0x89660
movq %rax, -0xc0(%rbp)
jmp 0x895b1
movq -0xc0(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x51e80
movq (%rax), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x51d30
jmp 0x895e1
xorl %eax, %eax
movl %eax, %esi
leaq -0xa0(%rbp), %rdi
callq 0xda90
movq -0xd0(%rbp), %rdi
movq (%rax), %rsi
callq 0x51d10
jmp 0x89602
leaq -0xa0(%rbp), %rdi
callq 0xd7d0
jmp 0x8962a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0xd7d0
jmp 0x8964c
jmp 0x8962c
leaq -0x38(%rbp), %rdi
callq 0x51c30
jmp 0x894c4
leaq -0x20(%rbp), %rdi
callq 0xdd90
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0xdd90
movq -0x50(%rbp), %rdi
callq 0x8880
nop
// File: Kei18[P]pibt/./src/solver/pibt.cpp
// Function: PIBT::updatePriority()
void PIBT::updatePriority() {
  // update priority
  for (int i = 0; i < A.size(); ++i) {
    // hasTask & not reach to goal
    if (A[i]->isUpdated()) {
      eta[i] = 0;
    } else if (A[i]->hasTask() && (A[i]->getNode() != A[i]->getGoal())) {
      eta[i] += 1;
    } else {
      eta[i] = 0;
    }
    priority[i] = eta[i] + epsilon[i];
    // priority[i] = getDensity(A[i]);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x20, %rdi
callq 0x383b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x89d7f
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movslq -0xc(%rbp), %rsi
callq 0x53720
movq (%rax), %rdi
callq 0x8be10
testb $0x1, %al
jne 0x89c5f
jmp 0x89c7e
movq -0x18(%rbp), %rdi
addq $0x80, %rdi
movslq -0xc(%rbp), %rsi
callq 0x4ea00
movl $0x0, (%rax)
jmp 0x89d18
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movslq -0xc(%rbp), %rsi
callq 0x53720
movq (%rax), %rdi
callq 0x3ae30
testb $0x1, %al
jne 0x89c9d
jmp 0x89cfc
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movslq -0xc(%rbp), %rsi
callq 0x53720
movq (%rax), %rdi
callq 0x51cb0
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x20, %rdi
movslq -0xc(%rbp), %rsi
callq 0x53720
movq (%rax), %rdi
callq 0x56820
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0x89cfc
movq -0x18(%rbp), %rdi
addq $0x80, %rdi
movslq -0xc(%rbp), %rsi
callq 0x4ea00
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x89d16
movq -0x18(%rbp), %rdi
addq $0x80, %rdi
movslq -0xc(%rbp), %rsi
callq 0x4ea00
movl $0x0, (%rax)
jmp 0x89d18
movq -0x18(%rbp), %rdi
addq $0x80, %rdi
movslq -0xc(%rbp), %rsi
callq 0x4ea00
movq -0x18(%rbp), %rdi
cvtsi2ssl (%rax), %xmm0
movss %xmm0, -0x30(%rbp)
addq $0x68, %rdi
movslq -0xc(%rbp), %rsi
callq 0x8baf0
movss -0x30(%rbp), %xmm0
movq -0x18(%rbp), %rdi
addss (%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
addq $0x98, %rdi
movslq -0xc(%rbp), %rsi
callq 0x8baf0
movss -0x2c(%rbp), %xmm0
movss %xmm0, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x89c1b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Kei18[P]pibt/./src/solver/pibt.cpp
// Function: PIBT::createCandidates(Agent*, std::vector<Node*, std::allocator<Node*>>)
Nodes PIBT::createCandidates(Agent* a, Nodes CLOSE_NODE) {
  Nodes C;
  for (auto v : G->neighbor(a->getNode())) {
    if (!inArray(v, CLOSE_NODE)) C.push_back(v);
  }
  if (!inArray(a->getNode(), CLOSE_NODE)) C.push_back(a->getNode());
  return C;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rcx, -0xa8(%rbp)
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x3e880
movq -0x90(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rdi
callq 0x51cb0
movq %rax, -0x80(%rbp)
jmp 0x8a1c8
movq -0x80(%rbp), %rdx
movq -0x88(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x3c8d0
jmp 0x8a1de
leaq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3b730
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3b760
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3b790
testb $0x1, %al
jne 0x8a230
leaq -0x48(%rbp), %rdi
callq 0xd7d0
jmp 0x8a2a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x8a332
leaq -0x60(%rbp), %rdi
callq 0x3bb00
movq -0xa8(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x8aa90
movb %al, -0xa9(%rbp)
jmp 0x8a258
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x8a292
jmp 0x8a264
movq -0xa0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3f490
jmp 0x8a276
jmp 0x8a292
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xd7d0
jmp 0x8a332
jmp 0x8a294
leaq -0x60(%rbp), %rdi
callq 0x3bad0
jmp 0x8a200
movq -0x18(%rbp), %rdi
callq 0x51cb0
movq %rax, -0xb8(%rbp)
jmp 0x8a2b4
movq -0xa8(%rbp), %rsi
movq -0xb8(%rbp), %rdi
callq 0x8aa90
movb %al, -0xb9(%rbp)
jmp 0x8a2cf
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x8a30c
jmp 0x8a2db
movq -0x18(%rbp), %rdi
callq 0x51cb0
movq %rax, -0xc8(%rbp)
jmp 0x8a2ed
movq -0xa0(%rbp), %rdi
movq -0xc8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x78(%rbp), %rsi
callq 0x4c210
jmp 0x8a30a
jmp 0x8a30c
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x8a322
movq -0xa0(%rbp), %rdi
callq 0xd7d0
movq -0x98(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0xd7d0
movq -0x50(%rbp), %rdi
callq 0x8880
nopw (%rax,%rax)
// File: Kei18[P]pibt/./src/solver/pibt.cpp
// Function: PIBT::createCandidates(Agent*, std::vector<Node*, std::allocator<Node*>>, Node*)
Nodes PIBT::createCandidates(Agent* a, Nodes CLOSE_NODE, Node* tmp) {
  CLOSE_NODE.push_back(tmp);
  Nodes C = createCandidates(a, CLOSE_NODE);
  CLOSE_NODE.erase(CLOSE_NODE.end() - 1);
  return C;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rcx, -0xa0(%rbp)
movq %rdi, %rax
movq -0xa0(%rbp), %rdi
movq %rax, -0x98(%rbp)
movq %rax, %rcx
movq %rcx, -0xa8(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x3f490
movq -0xa0(%rbp), %rsi
movb $0x0, -0x29(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3aff0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0x8a160
jmp 0x8a538
leaq -0x48(%rbp), %rdi
callq 0xd7d0
movq -0xa0(%rbp), %rdi
callq 0x3b760
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
movl $0x1, %esi
callq 0x4c520
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3f680
movq -0xa0(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x3f610
movq %rax, -0xb0(%rbp)
jmp 0x8a589
movq -0xb0(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x8a5dd
jmp 0x8a5d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xd7d0
jmp 0x8a5ed
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0xd7d0
jmp 0x8a5ed
movq -0x98(%rbp), %rdi
callq 0xd7d0
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x8880
nopw %cs:(%rax,%rax)
// File: Kei18[P]pibt/./src/solver/pibt.cpp
// Function: PIBT::updateC(std::vector<Node*, std::allocator<Node*>>&, Node*, std::vector<Node*, std::allocator<Node*>>)
void PIBT::updateC(Nodes& C, Node* target, Nodes CLOSE_NODE) {
  for (auto v : CLOSE_NODE) {
    auto itr2 = std::find_if(C.begin(), C.end(),
                             [v] (Node* u) { return v == u; });
    if (itr2 != C.end()) C.erase(itr2);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3b730
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3b760
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3b790
testb $0x1, %al
jne 0x8a9df
jmp 0x8aa7c
leaq -0x30(%rbp), %rdi
callq 0x3bb00
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b730
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b760
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x8afe0
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b760
movq %rax, -0x68(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3b790
testb $0x1, %al
jne 0x8aa46
jmp 0x8aa6c
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3f680
movq -0x80(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x3f610
movq %rax, -0x78(%rbp)
jmp 0x8aa6e
leaq -0x30(%rbp), %rdi
callq 0x3bad0
jmp 0x8a9c9
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Kei18[P]pibt/./src/solver/pibt.cpp
// Function: PIBT::logStr[abi:cxx11]()
std::string PIBT::logStr() {
  std::string str;
  str += "[solver] type:PIBT\n";
  str += Solver::logStr();
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x86b0
movq -0x50(%rbp), %rdi
leaq 0x2ba12(%rip), %rsi     # 0xb6a89
callq 0x84c0
jmp 0x8b07e
movq -0x58(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x9da50
jmp 0x8b08d
movq -0x50(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8640
jmp 0x8b09c
leaq -0x48(%rbp), %rdi
callq 0x8330
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x8b0df
jmp 0x8b0d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x8b0e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8330
jmp 0x8b0e9
movq -0x50(%rbp), %rdi
callq 0x8330
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x8330
movq -0x20(%rbp), %rdi
callq 0x8880
nopl (%rax,%rax)
// File: Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::init()
void PPS::init() {
  status = true;  // correct
  G->setRegFlg(true);
  for (auto a : A) {
    goals.push_back(a->getGoal());
    isTmpGoals.push_back(false);
  }

  // setup node lists, s.t., deg(v) >= 3
  for (auto v : G->getNodes()) {
    if (G->neighbor(v).size() >= 3) deg3nodes.push_back(v);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movb $0x1, 0x140(%rax)
movq 0x38(%rax), %rdi
movl $0x1, %esi
callq 0x62120
movq -0x98(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39b60
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x399f0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x51bd0
testb $0x1, %al
jne 0x8dd7b
jmp 0x8dddf
leaq -0x18(%rbp), %rdi
callq 0x51c10
movq %rax, %rcx
movq -0x98(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x28(%rbp)
addq $0x148, %rax            # imm = 0x148
movq %rax, -0xa0(%rbp)
movq -0x28(%rbp), %rdi
callq 0x56820
movq -0xa0(%rbp), %rdi
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x4c210
movq -0x98(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
xorl %esi, %esi
callq 0x96c10
leaq -0x18(%rbp), %rdi
callq 0x51c30
jmp 0x8dd68
movq -0x98(%rbp), %rax
movq 0x38(%rax), %rsi
leaq -0x50(%rbp), %rdi
callq 0x51ba0
leaq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3b730
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3b760
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3b790
testb $0x1, %al
jne 0x8de34
leaq -0x50(%rbp), %rdi
callq 0xd7d0
jmp 0x8decf
leaq -0x58(%rbp), %rdi
callq 0x3bb00
movq %rax, %rcx
movq -0x98(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x68(%rbp)
movq 0x38(%rax), %rsi
movq -0x68(%rbp), %rdx
leaq -0x80(%rbp), %rdi
callq 0x3c8d0
jmp 0x8de61
leaq -0x80(%rbp), %rdi
callq 0x3b0e0
movq %rax, -0xa8(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xd7d0
movq -0xa8(%rbp), %rax
cmpq $0x3, %rax
jb 0x8debf
movq -0x98(%rbp), %rdi
addq $0x188, %rdi            # imm = 0x188
leaq -0x68(%rbp), %rsi
callq 0x3f490
jmp 0x8dea0
jmp 0x8debf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xd7d0
jmp 0x8ded8
jmp 0x8dec1
leaq -0x58(%rbp), %rdi
callq 0x3bad0
jmp 0x8de15
addq $0xb0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x8880
nopw %cs:(%rax,%rax)
// File: Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::solve()
bool PPS::solve() {
  solveStart();

  // l.1, initialize
  pushers = A;
  U.clear();
  L.clear();

  while (!P->isSolved()) {  // l.2
    update();
    if (!status) {
      solveEnd();
      return false;
    }
    P->update();
    if (P->getTimestep() >= P->getTimestepLimit()) break;
  }

  solveEnd();
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq (%rdi), %rax
callq *(%rax)
movq -0x18(%rbp), %rdi
movq %rdi, %rsi
addq $0x20, %rsi
addq $0x68, %rdi
callq 0x62500
movq -0x18(%rbp), %rdi
addq $0xf8, %rdi
callq 0x577d0
movq -0x18(%rbp), %rdi
addq $0x110, %rdi            # imm = 0x110
callq 0x3e9f0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
xorb $-0x1, %al
testb $0x1, %al
jne 0x8e213
jmp 0x8e273
movq -0x18(%rbp), %rdi
callq 0x8e290
movq -0x18(%rbp), %rax
testb $0x1, 0x140(%rax)
jne 0x8e239
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x8e281
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x622f0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movq 0x10(%rax), %rdi
callq 0x62310
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jl 0x8e271
jmp 0x8e273
jmp 0x8e1fd
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::CHECK_PUSHER(Agent*)
CHECK PPS::CHECK_PUSHER(Agent* a) {
  // exclude swaper
  if (!inArray(a, pushers)) {
    return CHECK::INVALID;
  }

  // agent who becomes swaper
  if (inArray(a, pusherToSwaper)) {
    return CHECK::INVALID;
  }

  return CHECK::VALID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x68, %rsi
callq 0x8f430
testb $0x1, %al
jne 0x8f362
movl $0x1, -0x4(%rbp)
jmp 0x8f38c
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x98, %rsi
callq 0x8f430
testb $0x1, %al
jne 0x8f37c
jmp 0x8f385
movl $0x1, -0x4(%rbp)
jmp 0x8f38c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::inS(Agent*)
bool PPS::inS(Agent* a) {
  for (auto s : swapers) {
    if (inArray(s, doneSwapers)) continue;
    if (inArray(a, s->agents)) return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x80, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x96ce0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x96d10
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x96d40
testb $0x1, %al
jne 0x8f55f
jmp 0x8f5b5
leaq -0x28(%rbp), %rdi
callq 0x96d80
movq -0x40(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq $0xc8, %rsi
callq 0x8fd90
testb $0x1, %al
jne 0x8f589
jmp 0x8f58b
jmp 0x8f5aa
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x8, %rsi
callq 0x8f430
testb $0x1, %al
jne 0x8f5a2
jmp 0x8f5a8
movb $0x1, -0x1(%rbp)
jmp 0x8f5b9
jmp 0x8f5aa
leaq -0x28(%rbp), %rdi
callq 0x96da0
jmp 0x8f54c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::getS(Agent*)
S* PPS::getS(Agent* a) {
  auto itr = std::find_if(swapers.begin(), swapers.end(),
                          [a] (S* s) {
                            auto itrA = std::find(s->agents.begin(), s->agents.end(), a);
                            return itrA != s->agents.end(); });
  if (itr == swapers.end()) {
    std::cout << "error@PPS::getS, "
              << "corresponding swaper does not exist, "
              << "agent : " << a->getId() << "\n";
    std::exit(1);
  }
  return *itr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x80, %rdi
callq 0x96ce0
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x80, %rdi
callq 0x96d10
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x93dc0
movq -0x40(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x80, %rdi
callq 0x96d10
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x97150
testb $0x1, %al
jne 0x8fd10
jmp 0x8fd72
movq 0x71281(%rip), %rdi     # 0x100f98
leaq 0x270d8(%rip), %rsi     # 0xb6df6
callq 0x84d0
movq %rax, %rdi
leaq 0x270db(%rip), %rsi     # 0xb6e08
callq 0x84d0
movq %rax, %rdi
leaq 0x270f2(%rip), %rsi     # 0xb6e2e
callq 0x84d0
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x63b50
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0x8860
movq %rax, %rdi
leaq 0x23854(%rip), %rsi     # 0xb35b7
callq 0x84d0
movl $0x1, %edi
callq 0x85d0
leaq -0x18(%rbp), %rdi
callq 0x96d80
movq (%rax), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::SHORTEST_PATH(Agent*, Node*, std::vector<Node*, std::allocator<Node*>>&)
Nodes PPS::SHORTEST_PATH(Agent* c, Node* g, Nodes& T) {
  if (H.empty()) return G->getPath(c->getNode(), g, T);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
addq $0x128, %rdi            # imm = 0x128
callq 0x8bdd0
testb $0x1, %al
jne 0x9049a
jmp 0x904d6
movq -0x80(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
callq 0x51cb0
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq (%rsi), %rax
callq *0x20(%rax)
jmp 0x905d0
movq -0x28(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x3aff0
movq -0x80(%rbp), %rax
addq $0x128, %rax            # imm = 0x128
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x39b60
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x399f0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x51bd0
testb $0x1, %al
jne 0x9051e
jmp 0x9057e
leaq -0x50(%rbp), %rdi
callq 0x51c10
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x51cb0
movq %rax, -0xa0(%rbp)
jmp 0x90540
movq -0xa0(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x4c210
jmp 0x9055a
jmp 0x9055c
leaq -0x50(%rbp), %rdi
callq 0x51c30
jmp 0x9050b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xd7d0
jmp 0x905e0
movq -0x80(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x51cb0
movq %rax, -0xa8(%rbp)
jmp 0x9059f
movq -0xa8(%rbp), %rdx
movq -0xb0(%rbp), %rsi
movq -0x90(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq (%rsi), %rax
movq 0x20(%rax), %rax
leaq -0x40(%rbp), %r8
callq *%rax
jmp 0x905c7
leaq -0x40(%rbp), %rdi
callq 0xd7d0
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x8880
nopl (%rax)
// File: Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::move(Agent*, std::vector<Node*, std::allocator<Node*>>&)
void PPS::move(Agent* a, Nodes &pi) {
  // error check
  if (pi.size() < 2) {
    std::cout << "error@PPS::move, pi does not enough nodes" << "\n";
    std::exit(1);
  }

  a->setNode(pi[1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3b0e0
cmpq $0x2, %rax
jae 0x90d8f
movq 0x7022e(%rip), %rdi     # 0x100f98
leaq 0x25efa(%rip), %rsi     # 0xb6c6b
callq 0x84d0
movq %rax, %rdi
leaq 0x22837(%rip), %rsi     # 0xb35b7
callq 0x84d0
movl $0x1, %edi
callq 0x85d0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xda90
movq -0x20(%rbp), %rdi
movq (%rax), %rsi
callq 0x3a480
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::move(S*, std::vector<Node*, std::allocator<Node*>>&)
void PPS::move(S* s, Nodes &pi) {
  // error check
  if (s->phase != SWAPPHASE::GO_TARGET &&
      s->phase != SWAPPHASE::CLEARING) {
    std::cout << "error@PPS::move, invalid movement" << "\n";
    std::exit(1);
  }

  s->agents[0]->setNode(pi[1]);
  s->agents[1]->setNode(pi[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x78(%rax)
je 0x91354
movq -0x10(%rbp), %rax
cmpl $0x1, 0x78(%rax)
je 0x91354
movq 0x6fc69(%rip), %rdi     # 0x100f98
leaq 0x2595f(%rip), %rsi     # 0xb6c95
callq 0x84d0
movq %rax, %rdi
leaq 0x22272(%rip), %rsi     # 0xb35b7
callq 0x84d0
movl $0x1, %edi
callq 0x85d0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x53720
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xda90
movq -0x28(%rbp), %rdi
movq (%rax), %rsi
callq 0x3a480
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x53720
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xda90
movq -0x20(%rbp), %rdi
movq (%rax), %rsi
callq 0x3a480
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::DEPEND(std::vector<Node*, std::allocator<Node*>>, std::vector<Node*, std::allocator<Node*>>)
bool PPS::DEPEND(Nodes piA, Nodes piB) {
  // cond (a)
  if (inArray(piB[0], piA) && inArray(piB[piB.size()-1], piA)) return true;
  // cond (b)
  if (inArray(piB[0], piA) && inArray(piA[0], piB)) return true;

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rsi, -0x28(%rbp)
movq %rdi, -0x30(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0xda90
movq -0x28(%rbp), %rsi
movq (%rax), %rdi
callq 0x91410
testb $0x1, %al
jne 0x91522
jmp 0x91553
movq -0x30(%rbp), %rdi
callq 0x3b0e0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0xda90
movq -0x28(%rbp), %rsi
movq (%rax), %rdi
callq 0x91410
testb $0x1, %al
jne 0x9154d
jmp 0x91553
movb $0x1, -0x1(%rbp)
jmp 0x9159b
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xda90
movq -0x28(%rbp), %rsi
movq (%rax), %rdi
callq 0x91410
testb $0x1, %al
jne 0x91572
jmp 0x91597
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xda90
movq -0x30(%rbp), %rsi
movq (%rax), %rdi
callq 0x91410
testb $0x1, %al
jne 0x91591
jmp 0x91597
movb $0x1, -0x1(%rbp)
jmp 0x9159b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x128, %rdi            # imm = 0x128
callq 0x8bdd0
testb $0x1, %al
jne 0x91d03
jmp 0x91d3b
movq -0x78(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rdi
callq 0x51cb0
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
movq (%rsi), %rax
callq *0x18(%rax)
jmp 0x91e31
leaq -0x38(%rbp), %rdi
callq 0x3e880
movq -0x78(%rbp), %rax
addq $0x128, %rax            # imm = 0x128
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x39b60
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x399f0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x51bd0
testb $0x1, %al
jne 0x91d7f
jmp 0x91ddf
leaq -0x48(%rbp), %rdi
callq 0x51c10
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x51cb0
movq %rax, -0x98(%rbp)
jmp 0x91da1
movq -0x98(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4c210
jmp 0x91dbb
jmp 0x91dbd
leaq -0x48(%rbp), %rdi
callq 0x51c30
jmp 0x91d6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xd7d0
jmp 0x91e3e
movq -0x78(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x51cb0
movq %rax, -0xa0(%rbp)
jmp 0x91e00
movq -0xa0(%rbp), %rdx
movq -0xa8(%rbp), %rsi
movq -0x88(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq (%rsi), %rax
movq 0x20(%rax), %rax
leaq -0x38(%rbp), %r8
callq *%rax
jmp 0x91e28
leaq -0x38(%rbp), %rdi
callq 0xd7d0
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x8880
nopw (%rax,%rax)
// File: Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::CHECK_PRIORITY(S*, S*)
CHECK PPS::CHECK_PRIORITY(S* sC, S* sA) {
  if ((int)sA->phase >= (int)SWAPPHASE::CLEARING) {
    return CHECK::INVALID;
  }
  if (sC->id <= sA->id) return CHECK::VALID;
  return CHECK::INVALID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, 0x78(%rax)
jl 0x93723
movl $0x1, -0x4(%rbp)
jmp 0x93741
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x9373a
movl $0x0, -0x4(%rbp)
jmp 0x93741
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x70(%rbp)
movb $0x0, -0x19(%rbp)
addq $0x188, %rsi            # imm = 0x188
callq 0x3aff0
movq -0x70(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x51cb0
movq %rax, -0x68(%rbp)
jmp 0x93ac5
movq -0x80(%rbp), %rdi
movq -0x68(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x3b730
movq -0x80(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x3b760
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq 0x93b50
jmp 0x93b0e
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x93b3a
jmp 0x93b31
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0xd7d0
jmp 0x93b47
movq -0x80(%rbp), %rdi
callq 0xd7d0
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x8880
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x20, %rdi
callq 0x39b60
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x20, %rdi
callq 0x399f0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x93d60
movq -0x38(%rbp), %rsi
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
addq $0x110, %rsi            # imm = 0x110
callq 0x91410
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x86b0
movq -0x50(%rbp), %rdi
leaq 0x22f80(%rip), %rsi     # 0xb6e37
callq 0x84c0
jmp 0x93ebe
movq -0x58(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x9da50
jmp 0x93ecd
movq -0x50(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8640
jmp 0x93edc
leaq -0x48(%rbp), %rdi
callq 0x8330
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x93f1f
jmp 0x93f16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x93f29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8330
jmp 0x93f29
movq -0x50(%rbp), %rdi
callq 0x8330
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x8330
movq -0x20(%rbp), %rdi
callq 0x8880
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x10(%rax), %rdi
callq 0x9e060
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x38(%rax)
movq 0x10(%rax), %rsi
leaq -0x20(%rbp), %rdi
callq 0x9e080
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
leaq -0x20(%rbp), %rsi
callq 0x67360
leaq -0x20(%rbp), %rdi
callq 0xddf0
movq -0x48(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x80eb0
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rsi
movslq -0x24(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x9e0b0
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
leaq -0x40(%rbp), %rsi
callq 0x9e0f0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Kei18[P]pibt/./src/solver/solver.cpp
// Function: Solver::getMaxLengthPaths(std::vector<std::vector<Node*, std::allocator<Node*>>, std::allocator<std::vector<Node*, std::allocator<Node*>>>>&)
int Solver::getMaxLengthPaths(Paths& paths) {
  if (paths.empty()) return 0;
  auto itr = std::max_element(paths.begin(), paths.end(),
                              [] (Nodes p1, Nodes p2) {
                                return p1.size() < p2.size(); });
  return itr->size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9e3d0
testb $0x1, %al
jne 0x9d29f
jmp 0x9d2a8
movl $0x0, -0x4(%rbp)
jmp 0x9d2e7
movq -0x18(%rbp), %rdi
callq 0x377e0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x37500
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x9d2f0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4e680
movq %rax, %rdi
callq 0x3b0e0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9d280
movl %eax, -0x14(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x37930
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x9d3fe
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0xda70
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0xda70
movq %rax, %rdi
callq 0x3b0e0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0xda90
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0xda70
movq %rax, %rdi
callq 0x3b0e0
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
je 0x9d3ee
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0xda70
movq %rax, %rdi
leaq -0x20(%rbp), %rsi
callq 0x3f490
jmp 0x9d3b5
jmp 0x9d3f0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9d357
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x8890
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rdx
leaq 0x15cb4(%rip), %rsi     # 0xb35b8
callq 0xd8c0
jmp 0x9d90b
leaq -0x1a(%rbp), %rdi
callq 0x8540
movl -0xc(%rbp), %esi
leaq -0x50(%rbp), %rdi
callq 0xdf50
jmp 0x9d922
movq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8640
jmp 0x9d931
leaq -0x50(%rbp), %rdi
callq 0x8330
movq -0x80(%rbp), %rdi
leaq 0x19fae(%rip), %rsi     # 0xb78f3
callq 0x84c0
jmp 0x9d94c
movq -0x18(%rbp), %rdi
callq 0x3ae00
movl %eax, -0x8c(%rbp)
jmp 0x9d95d
movl -0x8c(%rbp), %esi
leaq -0x70(%rbp), %rdi
callq 0xdf50
jmp 0x9d96e
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x8640
jmp 0x9d97d
leaq -0x70(%rbp), %rdi
callq 0x8330
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x9d9ee
jmp 0x9d9e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x8540
jmp 0x9da07
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x9d9fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x8330
jmp 0x9d9fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x8330
jmp 0x9d9fe
movq -0x80(%rbp), %rdi
callq 0x8330
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x8330
movq -0x28(%rbp), %rdi
callq 0x8880
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x0, 0x68(%rax)
movb $0x1, 0xa0(%rax)
movq 0x10(%rax), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x28(%rax)
movq -0x78(%rbp), %rax
movq 0x38(%rax), %rdi
movl $0x1, %esi
callq 0x62120
movq -0x78(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39b60
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x399f0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x51bd0
testb $0x1, %al
jne 0xa084f
jmp 0xa0914
leaq -0x18(%rbp), %rdi
callq 0x51c10
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x28(%rbp)
addq $0x88, %rax
movq %rax, -0x88(%rbp)
movq -0x28(%rbp), %rdi
callq 0x51cb0
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x1, -0x48(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xd730
movq -0x80(%rbp), %rcx
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0xd750
jmp 0xa08b4
movq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xd700
jmp 0xa08c6
leaq -0x40(%rbp), %rdi
callq 0xd7d0
leaq -0x59(%rbp), %rdi
callq 0xd830
leaq -0x18(%rbp), %rdi
callq 0x51c30
jmp 0xa0839
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xa0909
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xd7d0
leaq -0x59(%rbp), %rdi
callq 0xd830
jmp 0xa091d
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x8880
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq (%rdi), %rax
callq *(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
xorb $-0x1, %al
testb $0x1, %al
jne 0xa0aef
jmp 0xa0b58
movq -0x18(%rbp), %rdi
movl 0x68(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x68(%rdi)
callq 0xa0b80
movq -0x18(%rbp), %rax
testb $0x1, 0xa0(%rax)
jne 0xa0b1e
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xa0b66
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x622f0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movq 0x10(%rax), %rdi
callq 0x62310
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jl 0xa0b56
jmp 0xa0b58
jmp 0xa0ad9
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Kei18[P]pibt/./src/solver/tp.cpp
// Function: TP::getNearestTask(Agent*, std::vector<Task*, std::allocator<Task*>>&)
Task* TP::getNearestTask(Agent* a, std::vector<Task*>& tasks) {
  if (tasks.empty()) {
    std::cout << "Error@TP::getNearestTask, cannot get task" << "\n";
    exit(1);
  }
  Node* v = a->getNode();
  Graph* _G = G;
  auto itr = std::min_element(tasks.begin(), tasks.end(),
                              [v, _G](Task* tau1, Task* tau2) {
                                return _G->dist(v, tau1->getG()[0])
                                  < _G->dist(v, tau2->getG()[0]); });
  return *itr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x55570
testb $0x1, %al
jne 0xa123b
jmp 0xa1267
movq 0x5fd56(%rip), %rdi     # 0x100f98
leaq 0x1665c(%rip), %rsi     # 0xb78a5
callq 0x84d0
movq %rax, %rdi
leaq 0x1235f(%rip), %rsi     # 0xb35b7
callq 0x84d0
movl $0x1, %edi
callq 0x85d0
movq -0x10(%rbp), %rdi
callq 0x51cb0
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3a140
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x39fd0
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0xa3d70
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x51e80
movq (%rax), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Kei18[P]pibt/./src/solver/tp.cpp
// Function: TP::shouldAvoid(Agent*, int)
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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x51cb0
movq %rax, %rcx
movq -0xb8(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rsi
leaq -0x50(%rbp), %rdi
callq 0x8bb10
leaq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3a140
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rdi
callq 0x39fd0
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x51e40
testb $0x1, %al
jne 0xa17d4
movl $0x2, -0x64(%rbp)
jmp 0xa18a1
leaq -0x58(%rbp), %rdi
callq 0x51e80
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x51d30
jmp 0xa17f6
movq -0x70(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x51d30
jmp 0xa1808
leaq -0xb0(%rbp), %rdi
callq 0x3b0e0
movq %rax, %rsi
subq $0x1, %rsi
leaq -0x88(%rbp), %rdi
callq 0xda90
movq (%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xd7d0
leaq -0x88(%rbp), %rdi
callq 0xd7d0
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0xa1891
movb $0x1, -0x1(%rbp)
movl $0x1, -0x64(%rbp)
jmp 0xa18a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0xa18b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xd7d0
jmp 0xa18b6
jmp 0xa1893
leaq -0x58(%rbp), %rdi
callq 0x51ea0
jmp 0xa17b7
leaq -0x50(%rbp), %rdi
callq 0xdd90
movl -0x64(%rbp), %eax
subl $0x1, %eax
je 0xa18c5
jmp 0xa18b4
jmp 0xa18c1
leaq -0x50(%rbp), %rdi
callq 0xdd90
jmp 0xa18d3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x8880
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x86b0
movq -0x50(%rbp), %rdi
leaq 0x13988(%rip), %rsi     # 0xb78cf
callq 0x84c0
jmp 0xa3f4e
movq -0x58(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x9da50
jmp 0xa3f5d
movq -0x50(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8640
jmp 0xa3f6c
leaq -0x48(%rbp), %rdi
callq 0x8330
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xa3faf
jmp 0xa3fa6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xa3fb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8330
jmp 0xa3fb9
movq -0x50(%rbp), %rdi
callq 0x8330
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x8330
movq -0x20(%rbp), %rdi
callq 0x8880
nopl (%rax,%rax)
// File: Kei18[P]pibt/./src/solver/whca.cpp
// Function: WHCA::logStr[abi:cxx11]()
std::string WHCA::logStr() {
  std::string str;
  str += "[solver] type:WHCA-" + std::to_string(window) + "\n";
  str += Solver::logStr();
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x86b0
movq -0xb0(%rbp), %rax
movl 0x6c(%rax), %esi
leaq -0x78(%rbp), %rdi
callq 0xdf50
jmp 0xac26d
leaq 0xb66d(%rip), %rsi      # 0xb78e1
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0xdf00
jmp 0xac283
leaq 0x732d(%rip), %rdx      # 0xb35b7
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xdeb0
jmp 0xac299
movq -0xc0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8640
jmp 0xac2ab
leaq -0x38(%rbp), %rdi
callq 0x8330
leaq -0x58(%rbp), %rdi
callq 0x8330
leaq -0x78(%rbp), %rdi
callq 0x8330
movq -0xb0(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x9da50
jmp 0xac2db
movq -0xc0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x8640
jmp 0xac2f0
leaq -0xa8(%rbp), %rdi
callq 0x8330
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xac397
jmp 0xac38b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xac3a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xac363
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xac35a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8330
leaq -0x58(%rbp), %rdi
callq 0x8330
leaq -0x78(%rbp), %rdi
callq 0x8330
jmp 0xac3a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x8330
jmp 0xac3a7
movq -0xc0(%rbp), %rdi
callq 0x8330
movq -0xb8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0xc0(%rbp), %rdi
callq 0x8330
movq -0x80(%rbp), %rdi
callq 0x8880
nopl (%rax)