LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/../util/util.h
// Function: void openToClose<std::vector<Agent*, std::allocator<Agent*>>>(std::vector<Agent*, std::allocator<Agent*>>, std::vector<std::vector<Agent*, std::allocator<Agent*>>, std::allocator<std::vector<Agent*, std::allocator<Agent*>>>>&, std::vector<std::vector<Agent*, std::allocator<Agent*>>, std::allocator<std::vector<Agent*, std::allocator<Agent*>>>>&)
static void openToClose(T a, std::vector<T>& OPEN, std::vector<T> &CLOSE) {
  auto itr = std::find(OPEN.begin(), OPEN.end(), a);
  if (itr != OPEN.end()) {
    CLOSE.push_back(*itr);
    OPEN.erase(itr);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %rdx
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
callq 0x23057
cmpq 0x8(%rbx), %rax
je 0x1f74d
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x2271c
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x23052
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/cbs.cpp
// Function: CBS::countCollisions(CTNode*, std::vector<std::vector<Node*, std::allocator<Node*>>, std::allocator<std::vector<Node*, std::allocator<Node*>>>>&)
int CBS::countCollisions(CTNode* c, Paths& paths) {
  int collision = 0;
  for (auto p1 : paths) {
    if (p1.empty()) continue;
    for (auto p2 : c->paths) {
      if (p2.empty() || p1[0] == p2[0]) continue;
      for (int t = 0; t < p1.size(); ++t) {
        if (p2.size() < t) {
          if (p1[t] == p2[p2.size() - 1]) ++collision;
          continue;
        }
        if (p1[t] == p2[t]) {
          ++collision;
          continue;
        }
        if (t > 0 && p1[t-1] == p2[t] && p1[t] == p2[t-2]) {
          ++collision;
          continue;
        }
      }
    }
  }

  return collision;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq (%rdx), %r14
movq 0x8(%rdx), %rax
movq %rax, 0x18(%rsp)
xorl %r15d, %r15d
leaq 0x20(%rsp), %r13
cmpq 0x18(%rsp), %r14
je 0x203d8
movq %rsp, %rdi
movq %r14, %rsi
callq 0x15d3a
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0x203c7
movq 0x18(%rbx), %rbp
movq 0x20(%rbx), %r12
cmpq %r12, %rbp
je 0x203c7
movq %r13, %rdi
movq %rbp, %rsi
callq 0x15d3a
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq %rcx, %rax
je 0x203b6
movq (%rsp), %rdx
movq (%rdx), %rsi
cmpq (%rax), %rsi
je 0x203b6
movq 0x8(%rsp), %rsi
subq %rdx, %rsi
sarq $0x3, %rsi
subq %rax, %rcx
movq %rcx, %rdi
sarq $0x3, %rdi
xorl %r8d, %r8d
cmpq %r8, %rsi
je 0x203b6
movq (%rdx,%r8,8), %r9
cmpq %r8, %rdi
jae 0x2038f
xorl %r10d, %r10d
cmpq -0x8(%rax,%rcx), %r9
sete %r10b
addl %r10d, %r15d
jmp 0x203b1
movq (%rax,%r8,8), %r10
cmpq %r10, %r9
je 0x203ae
testq %r8, %r8
je 0x203b1
cmpq %r10, -0x8(%rdx,%r8,8)
jne 0x203b1
xorl %r10d, %r10d
cmpq -0x10(%rax,%r8,8), %r9
jmp 0x20386
incl %r15d
incq %r8
jmp 0x20370
movq %r13, %rdi
callq 0x990e
addq $0x18, %rbp
jmp 0x20328
movq %rsp, %rdi
callq 0x990e
addq $0x18, %r14
jmp 0x202fb
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x990e
movq %rbx, %rdi
callq 0x6650
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/cbs.cpp
// Function: CBS::calcCost(CTNode*, std::vector<Agent*, std::allocator<Agent*>>&)
void CBS::calcCost(CTNode* node, Agents& block) {
  int cost = 0;
  Node* g;
  Nodes path;
  for (auto a : block) {
    auto itr1 = std::find_if(A.begin(), A.end(),
                            [a](Agent* b) { return a == b; });
    g = a->getGoal();
    path = node->paths[std::distance(A.begin(), itr1)];
    auto itr2 = path.end() - 1;
    while (g == *itr2) --itr2;
    cost += std::distance(path.begin(), itr2);
  }
  node->cost = cost;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rax
andq $0x0, 0x10(%rax)
movaps %xmm0, (%rax)
movq (%rdx), %r12
movq 0x8(%rdx), %r13
xorl %ebp, %ebp
cmpq %r13, %r12
je 0x20852
movq (%r12), %rcx
movq 0x20(%r14), %rax
movq 0x28(%r14), %rdx
movq %rdx, %rdi
subq %rax, %rdi
movq %rdi, %r8
sarq $0x5, %r8
movq %rax, %rsi
testq %r8, %r8
jle 0x207c7
cmpq %rcx, (%rsi)
je 0x20808
cmpq %rcx, 0x8(%rsi)
je 0x207f8
cmpq %rcx, 0x10(%rsi)
je 0x207fe
cmpq %rcx, 0x18(%rsi)
je 0x20804
addq $0x20, %rsi
decq %r8
addq $-0x20, %rdi
jmp 0x2079e
sarq $0x3, %rdi
cmpq $0x1, %rdi
je 0x207ef
cmpq $0x2, %rdi
je 0x207e6
cmpq $0x3, %rdi
jne 0x2080b
cmpq %rcx, (%rsi)
je 0x20808
addq $0x8, %rsi
cmpq %rcx, (%rsi)
je 0x20808
addq $0x8, %rsi
cmpq %rcx, (%rsi)
cmoveq %rsi, %rdx
jmp 0x2080b
addq $0x8, %rsi
jmp 0x20808
addq $0x10, %rsi
jmp 0x20808
addq $0x18, %rsi
movq %rsi, %rdx
movq 0x10(%rcx), %r15
subq %rax, %rdx
shrq $0x3, %rdx
imulq $0x18, %rdx, %rsi
addq 0x18(%rbx), %rsi
movq %rsp, %rdi
callq 0x16f90
movq 0x8(%rsp), %rax
leaq -0x8(%rax), %rcx
addq $-0x8, %rax
leaq -0x8(%rcx), %rdx
cmpq (%rcx), %r15
movq %rdx, %rcx
je 0x2082f
subq (%rsp), %rax
shrq $0x3, %rax
addl %eax, %ebp
addq $0x8, %r12
jmp 0x20779
movl %ebp, 0x30(%rbx)
movq %rsp, %rdi
callq 0x990e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x990e
movq %rbx, %rdi
callq 0x6650
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/cbs.cpp
// Function: CBS::formalizePathAgents(CTNode*, std::vector<Agent*, std::allocator<Agent*>>&)
void CBS::formalizePathAgents(CTNode* node, Agents& block) {
  int maxLength = getMaxLengthPaths(node->paths);
  Node* g;
  int i;
  for (auto a : block) {
    auto itr = std::find_if(A.begin(), A.end(),
                            [a](Agent* b) { return a == b; });
    i = std::distance(A.begin(), itr);
    g = node->paths[i][node->paths[i].size() - 1];
    while (node->paths[i].size() != maxLength) node->paths[i].push_back(g);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rbx
movq %rbx, %rsi
callq 0x32bac
movq (%r15), %r12
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rsp)
movslq %eax, %rbp
leaq 0x10(%rsp), %r15
cmpq 0x8(%rsp), %r12
je 0x20995
movq (%r12), %rsi
movq 0x20(%r14), %rax
movq 0x28(%r14), %rcx
movq %rcx, %rdi
subq %rax, %rdi
movq %rdi, %r8
sarq $0x5, %r8
movq %rax, %rdx
testq %r8, %r8
jle 0x20907
cmpq %rsi, (%rdx)
je 0x20948
cmpq %rsi, 0x8(%rdx)
je 0x20938
cmpq %rsi, 0x10(%rdx)
je 0x2093e
cmpq %rsi, 0x18(%rdx)
je 0x20944
addq $0x20, %rdx
decq %r8
addq $-0x20, %rdi
jmp 0x208de
sarq $0x3, %rdi
cmpq $0x1, %rdi
je 0x2092f
cmpq $0x2, %rdi
je 0x20926
cmpq $0x3, %rdi
jne 0x2094b
cmpq %rsi, (%rdx)
je 0x20948
addq $0x8, %rdx
cmpq %rsi, (%rdx)
je 0x20948
addq $0x8, %rdx
cmpq %rsi, (%rdx)
cmoveq %rdx, %rcx
jmp 0x2094b
addq $0x8, %rdx
jmp 0x20948
addq $0x10, %rdx
jmp 0x20948
addq $0x18, %rdx
movq %rdx, %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rax
movq (%rbx), %rdi
imulq $0x18, %rax, %r13
movq 0x8(%rdi,%r13), %rax
movq -0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rdi,%r13), %rax
subq (%rdi,%r13), %rax
sarq $0x3, %rax
cmpq %rbp, %rax
je 0x2098c
addq %r13, %rdi
movq %r15, %rsi
callq 0x171da
movq (%rbx), %rdi
jmp 0x2096a
addq $0x8, %r12
jmp 0x208b7
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/cbs.cpp
// Function: CBS::setCKey(Conflict*)
void CBS::setCKey(Conflict* c) {
  std::string key = std::to_string(c->a->getId()) + "_";
  key += std::to_string(c->t) + "_";
  if (c->onNode) {
    key += std::to_string(c->v->getId());
  } else {
    key += std::to_string(c->v->getId()) + "_" + std::to_string(c->u->getId());
  }
  c->key = key;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq (%rsi), %rax
movl (%rax), %esi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x943e
leaq 0x1baf5(%rip), %rdx     # 0x3c4bf
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x93fb
leaq 0x8(%rsp), %rdi
callq 0x61d0
movl 0x8(%rbx), %esi
leaq 0x28(%rsp), %rdi
callq 0x943e
leaq 0x1baca(%rip), %rdx     # 0x3c4bf
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x93fb
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
leaq 0x28(%rsp), %rdi
callq 0x61d0
cmpb $0x1, 0x20(%rbx)
jne 0x20a56
movq 0x10(%rbx), %rax
movl (%rax), %esi
leaq 0x8(%rsp), %rdi
callq 0x943e
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x66c0
leaq 0x8(%rsp), %rdi
jmp 0x20adb
movq 0x10(%rbx), %rax
movl (%rax), %esi
leaq 0x88(%rsp), %rdi
callq 0x943e
leaq 0x1ba4f(%rip), %rdx     # 0x3c4bf
leaq 0x28(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x93fb
movq 0x18(%rbx), %rax
movl (%rax), %esi
leaq 0x68(%rsp), %rdi
callq 0x943e
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x229b6
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
leaq 0x68(%rsp), %rdi
callq 0x61d0
leaq 0x28(%rsp), %rdi
callq 0x61d0
leaq 0x88(%rsp), %rdi
callq 0x61d0
addq $0x28, %rbx
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x6240
leaq 0x48(%rsp), %rdi
callq 0x61d0
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x61d0
jmp 0x20b18
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x61d0
jmp 0x20b27
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x61d0
jmp 0x20b36
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
jmp 0x20b67
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x20b67
jmp 0x20b6e
jmp 0x20b6e
jmp 0x20b6e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x61d0
jmp 0x20b62
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x61d0
jmp 0x20b71
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x61d0
movq %rbx, %rdi
callq 0x6650
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x20b76
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/cbs.cpp
// Function: CBS::getConstraints(CTNode*)
Constraint CBS::getConstraints(CTNode* ctNode) {
  Constraint constraints = {};
  CTNode* p = ctNode;
  while (p != nullptr) {
    for (auto c : p->c) constraints.push_back(c);
    p = p->p;
  }
  return constraints;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %r15
testq %r14, %r14
je 0x20be2
movq (%r14), %r12
movq 0x8(%r14), %r13
cmpq %r13, %r12
je 0x20bdc
movq (%r12), %rax
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22936
addq $0x8, %r12
jmp 0x20bbd
movq 0x38(%r14), %r14
jmp 0x20bb1
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x235f6
movq %r14, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/cbs.cpp
// Function: CBS::getConstraintsForAgent(CTNode*, Agent*)
Constraint CBS::getConstraintsForAgent(CTNode* ctNode, Agent* a) {
  Constraint constraints = {};
  CTNode* p = ctNode;
  while (p != nullptr) {
    for (auto c : p->c) {
      if (c->a == a) constraints.push_back(c);
    }
    p = p->p;
  }
  return constraints;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsp, %r12
testq %r15, %r15
je 0x216dd
movq (%r15), %r13
movq 0x8(%r15), %rbp
cmpq %rbp, %r13
je 0x216d7
movq (%r13), %rax
movq %rax, (%rsp)
cmpq %r14, (%rax)
jne 0x216d1
movq %rbx, %rdi
movq %r12, %rsi
callq 0x22936
addq $0x8, %r13
jmp 0x216b4
movq 0x38(%r15), %r15
jmp 0x216a8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x235f6
movq %r14, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/cbs.cpp
// Function: CBS::getCKey[abi:cxx11](Node*, Node*, std::vector<Conflict*, std::allocator<Conflict*>>&)
std::string CBS::getCKey(Node* s, Node* g, Constraint &constraints) {
  std::string key = std::to_string(s->getId()) + "-" + std::to_string(g->getId());
  for (auto c : constraints) {
    key += "-" + c->key;
  }
  return key;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
movl (%rdx), %esi
leaq 0x40(%rsp), %r12
movq %r12, %rdi
callq 0x943e
leaq 0x1cc39(%rip), %rdx     # 0x3e367
movq %rsp, %rdi
movq %r12, %rsi
callq 0x93fb
movl (%r15), %esi
leaq 0x20(%rsp), %rdi
callq 0x943e
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x229b6
leaq 0x20(%rsp), %rdi
callq 0x61d0
movq %rsp, %r15
movq %r15, %rdi
callq 0x61d0
leaq 0x40(%rsp), %rdi
callq 0x61d0
movq (%r14), %r12
movq 0x8(%r14), %r13
leaq 0x1cbe4(%rip), %r14     # 0x3e367
cmpq %r13, %r12
je 0x217b4
movq (%r12), %rdx
addq $0x28, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x9497
movq %rbx, %rdi
movq %r15, %rsi
callq 0x66c0
movq %r15, %rdi
callq 0x61d0
addq $0x8, %r12
jmp 0x21783
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x61d0
jmp 0x217d7
movq %rax, %r14
movq %rsp, %rdi
callq 0x61d0
jmp 0x217e4
movq %rax, %r14
leaq 0x40(%rsp), %rdi
jmp 0x217fe
movq %rax, %r14
jmp 0x217fb
movq %rax, %r14
movq %rsp, %rdi
callq 0x61d0
movq %rbx, %rdi
callq 0x61d0
movq %r14, %rdi
callq 0x6650
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/cbs.cpp
// Function: CBS::isDuplicatedConflict(Conflict*, Conflict*)
bool CBS::isDuplicatedConflict(Conflict* c1, Conflict* c2) {
  if (c1->a != c2->a) return false;
  if (c1->t != c2->t) return false;
  if (c1->v != c2->v) return false;
  if (c1->onNode != c2->onNode) return false;
  if (!c1->onNode && c1->u != c2->u) return false;
  return true;
}

// Assembly:
movq (%rsi), %rax
cmpq (%rdx), %rax
jne 0x21a32
movl 0x8(%rsi), %eax
cmpl 0x8(%rdx), %eax
jne 0x21a32
movq 0x10(%rsi), %rax
cmpq 0x10(%rdx), %rax
jne 0x21a32
movb 0x20(%rsi), %al
cmpb 0x20(%rdx), %al
jne 0x21a32
testb %al, %al
jne 0x21a35
movq 0x18(%rsi), %rax
cmpq 0x18(%rdx), %rax
je 0x21a35
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/cbs.cpp
// Function: CBS::logStr[abi:cxx11]()
std::string CBS::logStr() {
  std::string str;
  str += "[solver] type:CBS\n";
  str += "[solver] ID:" + std::to_string(ID) + "\n";
  str += Solver::logStr();
  return str;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x1a887(%rip), %rsi     # 0x3c4c1
callq 0x66a0
movzbl 0x68(%r14), %esi
leaq 0x28(%rsp), %rdi
callq 0x943e
leaq 0x1a87f(%rip), %rsi     # 0x3c4d4
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x941a
leaq 0x188f8(%rip), %rdx     # 0x3a563
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x93fb
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
leaq 0x48(%rsp), %rdi
callq 0x61d0
leaq 0x28(%rsp), %rdi
callq 0x61d0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x32ffe
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x21d06
jmp 0x21d0f
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x61d0
jmp 0x21cf2
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x61d0
jmp 0x21d01
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x61d0
jmp 0x21d12
jmp 0x21d0f
movq %rax, %r14
movq %rbx, %rdi
callq 0x61d0
movq %r14, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/ecbs.cpp
// Function: ECBS::getPartialPath(AN*, std::vector<Node*, std::allocator<Node*>>&)
void ECBS::getPartialPath(AN* n, Nodes &path) {
  path.clear();
  AN* m = n;
  while (m != nullptr) {
    path.push_back(m->v);
    m = m->p;
  }
  std::reverse(path.begin(), path.end());
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0x26a0e
movq %rax, 0x8(%rbx)
jmp 0x26a0e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x171da
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x269ff
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x18697
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/ecbs.cpp
// Function: ECBS::logStr[abi:cxx11]()
std::string ECBS::logStr() {
  std::string str;
  str += "[solver] type:ECBS\n";
  str += "[solver] w:" + std::to_string(w) + "\n";
  str += "[solver] ID:" + std::to_string(ID) + "\n";
  str += Solver::logStr();
  return str;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x15b61(%rip), %rsi     # 0x3c5ab
callq 0x66a0
movss 0xa8(%r14), %xmm0
leaq 0x28(%rsp), %rdi
callq 0x1e10d
leaq 0x15b56(%rip), %rsi     # 0x3c5bf
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x941a
leaq 0x13ae4(%rip), %rdx     # 0x3a563
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x93fb
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
leaq 0x48(%rsp), %rdi
callq 0x61d0
leaq 0x28(%rsp), %rdi
callq 0x61d0
movzbl 0x68(%r14), %esi
leaq 0x28(%rsp), %rdi
callq 0x943e
leaq 0x15a05(%rip), %rsi     # 0x3c4d4
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x941a
leaq 0x13a7e(%rip), %rdx     # 0x3a563
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x93fb
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
leaq 0x48(%rsp), %rdi
callq 0x61d0
leaq 0x28(%rsp), %rdi
callq 0x61d0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x32ffe
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x26b88
jmp 0x26b91
jmp 0x26b62
jmp 0x26b71
jmp 0x26b80
jmp 0x26b91
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x61d0
jmp 0x26b74
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x61d0
jmp 0x26b83
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x61d0
jmp 0x26b94
jmp 0x26b91
movq %rax, %r14
movq %rbx, %rdi
callq 0x61d0
movq %r14, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/iecbs.cpp
// Function: iECBS::logStr[abi:cxx11]()
std::string iECBS::logStr() {
  std::string str;
  str += "[solver] type:iECBS\n";
  str += "[solver] w:" + std::to_string(w) + "\n";
  str += "[solver] highway:" + highwayFile + "\n";
  str += "[solver] ID:" + std::to_string(ID) + "\n";
  str += Solver::logStr();
  return str;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x120f9(%rip), %rsi     # 0x3c8e3
callq 0x66a0
movss 0xa8(%r14), %xmm0
leaq 0x48(%rsp), %rdi
callq 0x1e10d
leaq 0x11db6(%rip), %rsi     # 0x3c5bf
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x941a
leaq 0xfd44(%rip), %rdx      # 0x3a563
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x93fb
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
leaq 0x28(%rsp), %rdi
callq 0x61d0
leaq 0x48(%rsp), %rdi
callq 0x61d0
leaq 0xf0(%r14), %rdx
leaq 0x12091(%rip), %rsi     # 0x3c8f8
leaq 0x28(%rsp), %rdi
callq 0x9497
leaq 0xfceb(%rip), %rdx      # 0x3a563
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x93fb
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
leaq 0x28(%rsp), %rdi
callq 0x61d0
movzbl 0x68(%r14), %esi
leaq 0x48(%rsp), %rdi
callq 0x943e
leaq 0x11c16(%rip), %rsi     # 0x3c4d4
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x941a
leaq 0xfc8f(%rip), %rdx      # 0x3a563
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x93fb
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
leaq 0x28(%rsp), %rdi
callq 0x61d0
leaq 0x48(%rsp), %rdi
callq 0x61d0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x32ffe
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x2a992
jmp 0x2a99b
jmp 0x2a96c
jmp 0x2a97b
jmp 0x2a98a
jmp 0x2a99b
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x61d0
jmp 0x2a963
movq %rax, %r14
leaq 0x28(%rsp), %rdi
jmp 0x2a992
jmp 0x2a99b
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x61d0
jmp 0x2a97e
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x61d0
jmp 0x2a98d
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x61d0
jmp 0x2a99e
jmp 0x2a99b
movq %rax, %r14
movq %rbx, %rdi
callq 0x61d0
movq %r14, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/pibt.cpp
// Function: PIBT::init()
void PIBT::init() {
  G->setRegFlg(true);

  // initialize priroirty
  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]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movb $0x1, 0x9(%rax)
movq 0x28(%rdi), %r12
subq 0x20(%rdi), %r12
shrq $0x3, %r12
cvtsi2ss %r12d, %xmm0
movss %xmm0, 0x8(%rsp)
leaq 0x68(%rdi), %r14
leaq 0x80(%rdi), %r15
addq $0x98, %rbx
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
leaq 0xc(%rsp), %rbp
cmpq %r13, %r12
je 0x2c9ec
cvtsi2ss %r13d, %xmm0
divss 0x8(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
movq %r14, %rdi
leaq 0x14(%rsp), %rsi
callq 0x2da4e
andl $0x0, 0x10(%rsp)
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
callq 0x1d402
movq (%r15), %rax
cvtsi2ssl (%rax,%r13,4), %xmm0
movq (%r14), %rax
addss (%rax,%r13,4), %xmm0
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2da4e
incq %r13
jmp 0x2c98f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/pibt.cpp
// Function: PIBT::solve()
bool PIBT::solve() {
  solveStart();

  while (!P->isSolved()) {
    allocate();
    update();
    P->update();
    if (P->getTimestep() >= P->getTimestepLimit()) break;
  }

  solveEnd();
  return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
jne 0x2cafc
movq %rbx, %rdi
callq 0x2cb0a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rbx), %rdi
movl 0x8(%rdi), %eax
cmpl 0xc(%rdi), %eax
jl 0x2cacb
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movb $0x1, %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
jne 0x2cc5d
movq 0x10(%r14), %rsi
addq $0x30, %rsi
leaq 0x30(%rsp), %rdi
callq 0x9398
movq 0x38(%r14), %rbx
movq 0x20(%r14), %r12
movq 0x28(%r14), %r14
leaq 0x60(%rsp), %r13
movq %r14, 0x10(%rsp)
cmpq %r14, %r12
je 0x2cc53
movq (%r12), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x2cc4a
movq 0x30(%rsp), %r15
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq %rax, %r15
je 0x2cc45
movq %r12, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%r15), %r14
cmpq 0x28(%rsp), %r14
je 0x2cc15
movq (%r14), %rsi
movq (%r15), %r12
movq %r13, %rbp
movq %r13, %rdi
callq 0x15d3a
movq 0x60(%rsp), %rax
movq (%rax), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
movq 0x8(%rsp), %rdx
callq *0x10(%rax)
movl %eax, %r13d
leaq 0x48(%rsp), %rdi
movq %r12, %rsi
callq 0x15d3a
movq 0x48(%rsp), %rax
movq (%rax), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
movq 0x8(%rsp), %rdx
callq *0x10(%rax)
movl %eax, %r12d
leaq 0x48(%rsp), %rdi
callq 0x990e
movq %rbp, %rdi
callq 0x990e
cmpl %r12d, %r13d
movq %rbp, %r13
cmovlq %r14, %r15
addq $0x8, %r14
jmp 0x2cb9c
movq (%r15), %rsi
movq %r13, %rdi
callq 0x15d3a
movq 0x60(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movq %rax, 0x10(%rcx)
movq %r13, %rdi
callq 0x990e
movq 0x20(%rsp), %r12
movq 0x10(%rsp), %r14
jmp 0x2cc4a
callq 0x15a18
addq $0x8, %r12
jmp 0x2cb55
leaq 0x30(%rsp), %rdi
callq 0x154b6
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2cc70
jmp 0x2cc70
movq %rax, %rbx
jmp 0x2cc93
jmp 0x2cc77
movq %rax, %rbx
jmp 0x2cc89
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x990e
leaq 0x60(%rsp), %rdi
callq 0x990e
leaq 0x30(%rsp), %rdi
callq 0x154b6
movq %rbx, %rdi
callq 0x6650
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/pibt.cpp
// Function: PIBT::update()
void PIBT::update() {
  updatePriority();

  std::vector<float> PL(priority.size());  // priority list
  std::copy(priority.begin(), priority.end(), PL.begin());

  Nodes CLOSE_NODE;
  Agents OPEN_AGENT(A.size());
  std::copy(A.begin(), A.end(), OPEN_AGENT.begin());

  // choose one agent with the highest priority
  auto itr = std::max_element(PL.begin(), PL.end());
  int index = std::distance(PL.begin(), itr);
  Agent* a = OPEN_AGENT[index];

  while (!OPEN_AGENT.empty()) {
    priorityInheritance(a, CLOSE_NODE, OPEN_AGENT, PL);

    itr = std::max_element(PL.begin(), PL.end());
    index = std::distance(PL.begin(), itr);
    a = OPEN_AGENT[index];
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x20(%rax)
movq 0xa0(%rbx), %rsi
subq 0x98(%rbx), %rsi
sarq $0x2, %rsi
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x2d89e
movq 0x98(%rbx), %rsi
movq 0xa0(%rbx), %rdx
subq %rsi, %rdx
je 0x2ccf8
movq 0x10(%rsp), %rdi
callq 0x65c0
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
andq $0x0, 0x50(%rsp)
movq 0x28(%rbx), %rsi
subq 0x20(%rbx), %rsi
sarq $0x3, %rsi
leaq 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2d8f0
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
subq %rsi, %rdx
je 0x2cd38
movq 0x28(%rsp), %rdi
callq 0x65c0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2d9ef
leaq 0x10(%rsp), %r14
subq (%r14), %rax
shlq $0x1e, %rax
leaq 0x28(%rsp), %r15
movq (%r15), %rcx
sarq $0x1d, %rax
addq %rcx, %rax
leaq 0x40(%rsp), %r12
cmpq 0x30(%rsp), %rcx
je 0x2cda8
movq (%rax), %rsi
movq %rbx, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x2ce04
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2d9ef
subq 0x10(%rsp), %rax
shlq $0x1e, %rax
movq 0x28(%rsp), %rcx
sarq $0x1d, %rax
addq %rcx, %rax
jmp 0x2cd67
leaq 0x28(%rsp), %rdi
callq 0x15420
leaq 0x40(%rsp), %rdi
callq 0x990e
leaq 0x10(%rsp), %rdi
callq 0x2da1a
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2cddb
movq %rax, %rbx
jmp 0x2cde8
jmp 0x2cddb
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x15420
leaq 0x40(%rsp), %rdi
callq 0x990e
leaq 0x10(%rsp), %rdi
callq 0x2da1a
movq %rbx, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq 0x80(%rdi), %rdx
movq 0x68(%rdi), %rsi
movq 0x98(%rdi), %rdi
xorl %r8d, %r8d
cmpq %r8, %rcx
je 0x2cf2e
movq (%rax,%r8,8), %r9
cmpb $0x1, 0x38(%r9)
je 0x2cf15
cmpq $0x0, 0x18(%r9)
je 0x2cf15
movq 0x8(%r9), %r10
cmpq 0x10(%r9), %r10
je 0x2cf15
movl (%rdx,%r8,4), %r9d
incl %r9d
movl %r9d, (%rdx,%r8,4)
cvtsi2ss %r9d, %xmm0
jmp 0x2cf1d
andl $0x0, (%rdx,%r8,4)
xorps %xmm0, %xmm0
addss (%rsi,%r8,4), %xmm0
movss %xmm0, (%rdi,%r8,4)
incq %r8
jmp 0x2cee2
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/pibt.cpp
// Function: PIBT::getDensity(Agent*)
float PIBT::getDensity(Agent* a) {
  float density = 0;
  Node *v, *u;
  int d, tmp;
  v = a->getNode();
  Nodes Ci, Cj;
  Ci = G->neighbor(v);

  for (auto b : A) {
    if (b == a) continue;
    u = b->getNode();
    d = G->dist(u, v);
    if (G->dist(u, v) > 2) continue;
    tmp = - d + 2;
    Cj = G->neighbor(u);
    for (auto w : Cj) {
      if (w == v) {
        tmp += 2;
      } else if (G->dist(w, u) == 1) {
        ++tmp;
      }
    }
    density += (float)tmp / (float)Cj.size();
  }

  density /= (float)Ci.size();
  return density;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq 0x38(%rdi), %rsi
leaq 0x60(%rsp), %rdi
movq %r15, %rdx
callq 0x164ca
leaq 0x30(%rsp), %rdi
leaq 0x60(%rsp), %r12
movq %r12, %rsi
callq 0x18466
movq %r12, %rdi
callq 0x990e
movq 0x20(%r14), %rcx
movq 0x28(%r14), %rax
movq %rax, 0x58(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rsp)
movq %rbx, 0x50(%rsp)
cmpq 0x58(%rsp), %rcx
je 0x2d0b7
movq (%rcx), %rax
cmpq %rbx, %rax
je 0x2d0ae
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rbp
movq 0x38(%r14), %rdi
movq (%rdi), %rax
movq %rbp, %rsi
movq %r15, %rdx
callq *0x10(%rax)
movl %eax, %r13d
movq 0x38(%r14), %rdi
movq (%rdi), %rax
movq %rbp, %rsi
movq %r15, %rdx
callq *0x10(%rax)
cmpl $0x2, %eax
jle 0x2cff9
movq 0x8(%rsp), %rcx
jmp 0x2d0ae
movq 0x38(%r14), %rsi
movq %r12, %rdi
movq %rbp, %rdx
callq 0x164ca
pushq $0x2
popq %rbx
subl %r13d, %ebx
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x18466
movq %r12, %rdi
callq 0x990e
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %r12
cmpq %r12, %r13
je 0x2d05b
movq (%r13), %rsi
pushq $0x2
popq %rcx
cmpq %r15, %rsi
je 0x2d053
movq 0x38(%r14), %rdi
movq (%rdi), %rax
movq %rbp, %rdx
callq *0x10(%rax)
xorl %ecx, %ecx
cmpl $0x1, %eax
sete %cl
addl %ecx, %ebx
addq $0x8, %r13
jmp 0x2d02d
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
sarq $0x3, %rax
js 0x2d072
cvtsi2ss %rax, %xmm0
jmp 0x2d087
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
leaq 0x60(%rsp), %r12
movq 0x8(%rsp), %rcx
cvtsi2ss %ebx, %xmm1
divss %xmm0, %xmm1
movss 0x4(%rsp), %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x50(%rsp), %rbx
addq $0x8, %rcx
jmp 0x2cfa7
movq 0x38(%rsp), %rax
subq 0x30(%rsp), %rax
sarq $0x3, %rax
js 0x2d0ce
cvtsi2ss %rax, %xmm0
jmp 0x2d0e3
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
movss 0x4(%rsp), %xmm1
divss %xmm0, %xmm1
movss %xmm1, 0x4(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x990e
leaq 0x30(%rsp), %rdi
callq 0x990e
movss 0x4(%rsp), %xmm0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d122
jmp 0x2d122
jmp 0x2d122
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x990e
leaq 0x30(%rsp), %rdi
callq 0x990e
movq %rbx, %rdi
callq 0x6650
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x38(%rsi), %rsi
movq 0x8(%rdx), %rdx
leaq 0x10(%rsp), %rdi
callq 0x164ca
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %rbp
leaq 0x8(%rsp), %r12
cmpq %rbp, %r13
je 0x2d1b0
movq (%r13), %rdi
movq %rdi, 0x8(%rsp)
movq %r15, %rsi
callq 0x2d58b
testb %al, %al
jne 0x2d1aa
movq %rbx, %rdi
movq %r12, %rsi
callq 0x171da
addq $0x8, %r13
jmp 0x2d185
leaq 0x10(%rsp), %rdi
callq 0x990e
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x2d58b
testb %al, %al
jne 0x2d1de
movq 0x8(%r14), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x1aca4
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d1f4
jmp 0x2d1f4
movq %rax, %r14
jmp 0x2d206
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x990e
movq %rbx, %rdi
callq 0x990e
movq %r14, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %rsp, %rsi
movq %r8, (%rsi)
movq %rcx, %rdi
callq 0x171da
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x15d3a
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x2d142
leaq 0x8(%rsp), %rdi
callq 0x990e
movq 0x8(%r14), %rsi
addq $-0x8, %rsi
movq %r14, %rdi
callq 0x2d9b6
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %r15
jmp 0x2d362
movq %rax, %r14
movq %r15, %rdi
callq 0x990e
movq %r14, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/pibt.cpp
// Function: PIBT::priorityInheritance(Agent*, std::vector<Node*, std::allocator<Node*>>, std::vector<Node*, std::allocator<Node*>>&, std::vector<Agent*, std::allocator<Agent*>>&, std::vector<float, std::allocator<float>>&)
bool PIBT::priorityInheritance(Agent* a,
                               Nodes C,
                               Nodes& CLOSE_NODE,
                               Agents& OPEN_AGENT,
                               std::vector<float>& PL)
{
  // remove agent from OPEN_AGENT, Priority List
  auto itr = std::find(OPEN_AGENT.begin(), OPEN_AGENT.end(), a);
  PL.erase(PL.begin() + std::distance(OPEN_AGENT.begin(), itr));
  OPEN_AGENT.erase(itr);

  Node* target;

  // main loop
  while (!C.empty()) {

    // choose target
    target = chooseNode(a, C);
    CLOSE_NODE.push_back(target);

    bool isAgent = false;
    for (auto b : OPEN_AGENT) {
      if (target == b->getNode()) {  // If there is an agent
        if (priorityInheritance(b, a, CLOSE_NODE, OPEN_AGENT, PL)) {
          // priority inheritance success
          a->setNode(target);
          return true;
        } else {
          // priority inheritance fail
          updateC(C, target, CLOSE_NODE);
          isAgent = true;
          break;
        }
      }
    }

    // If there is an agent
    if (!isAgent) {
      a->setNode(target);
      return true;
    }
  }

  // failed
  a->setNode(a->getNode());
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %r15
movq %r8, %r14
movq %rcx, 0x20(%rsp)
movq %rdx, %r12
movq %rdi, 0x10(%rsp)
movq %rsp, %rdx
movq %rsi, (%rdx)
movq (%r8), %rdi
movq 0x8(%r8), %rsi
callq 0x2dcba
movq %rax, %rbx
movq %rax, %rsi
subq (%r14), %rsi
sarq %rsi
addq (%r15), %rsi
movq %r15, 0x18(%rsp)
movq %r15, %rdi
callq 0x2d942
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2d97c
leaq 0x40(%rsp), %rbp
movq (%r12), %r15
movq 0x8(%r12), %r13
movq (%rsp), %rbx
cmpq %r13, %r15
je 0x2d4a6
movq %rbp, %rdi
movq %r12, %rsi
callq 0x15d3a
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
movq %rbp, %rdx
callq *0x30(%rax)
movq %rax, 0x8(%rsp)
movq %rbp, %rdi
callq 0x990e
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0x171da
movq (%r14), %rcx
movq 0x8(%r14), %rdx
movq 0x8(%rsp), %rsi
cmpq %rdx, %rcx
je 0x2d488
movq (%rcx), %rax
addq $0x8, %rcx
cmpq 0x8(%rax), %rsi
jne 0x2d42e
movq (%rsp), %rdx
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq %rbx, %rcx
movq %r14, %r8
movq 0x18(%rsp), %r9
callq 0x2d216
testb %al, %al
jne 0x2d4af
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x15d3a
movq %r12, %rsi
movq %r15, %rcx
callq 0x2d4d6
movq %r15, %rdi
callq 0x990e
jmp 0x2d3d1
movq (%rsp), %rdi
callq 0x158b4
cmpq %r13, %r15
setne %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
jmp 0x2d48c
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
jmp 0x2d48c
movq %rax, %rbx
movq %r15, %rbp
jmp 0x2d4c5
movq %rax, %rbx
movq %rbp, %rdi
callq 0x990e
movq %rbx, %rdi
callq 0x6650
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rcx), %r14
movq 0x8(%rcx), %r15
cmpq %r15, %r14
je 0x2d585
movq (%r14), %rcx
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
movq %rax, %rdx
subq %rsi, %rdx
movq %rdx, %rdi
sarq $0x5, %rdi
testq %rdi, %rdi
jle 0x2d52e
cmpq %rcx, (%rsi)
je 0x2d56f
cmpq %rcx, 0x8(%rsi)
je 0x2d55f
cmpq %rcx, 0x10(%rsi)
je 0x2d565
cmpq %rcx, 0x18(%rsi)
je 0x2d56b
addq $0x20, %rsi
decq %rdi
addq $-0x20, %rdx
jmp 0x2d505
sarq $0x3, %rdx
cmpq $0x1, %rdx
je 0x2d556
cmpq $0x2, %rdx
je 0x2d54d
cmpq $0x3, %rdx
jne 0x2d57c
cmpq %rcx, (%rsi)
je 0x2d56f
addq $0x8, %rsi
cmpq %rcx, (%rsi)
je 0x2d56f
addq $0x8, %rsi
cmpq %rcx, (%rsi)
cmovneq %rax, %rsi
jmp 0x2d56f
addq $0x8, %rsi
jmp 0x2d56f
addq $0x10, %rsi
jmp 0x2d56f
addq $0x18, %rsi
cmpq %rax, %rsi
je 0x2d57c
movq %rbx, %rdi
callq 0x2d9b6
addq $0x8, %r14
jmp 0x2d4e5
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0xfd63(%rip), %rsi      # 0x3d5a9
callq 0x66a0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x32ffe
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x61d0
jmp 0x2d88e
jmp 0x2d88b
movq %rax, %r14
movq %rbx, %rdi
callq 0x61d0
movq %r14, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movb $0x1, %al
movb %al, 0x140(%rdi)
movq 0x38(%rdi), %rcx
movb %al, 0x9(%rcx)
movq 0x20(%rdi), %r13
movq 0x28(%rdi), %rbp
leaq 0x148(%rdi), %r14
leaq 0x160(%rdi), %r15
leaq 0x8(%rsp), %r12
cmpq %rbp, %r13
je 0x2df18
movq (%r13), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x1aca4
movq %r15, %rdi
xorl %esi, %esi
callq 0x3154c
addq $0x8, %r13
jmp 0x2deeb
movq 0x38(%rbx), %rsi
addq $0x10, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x15d3a
movq (%r14), %r13
movq 0x8(%r14), %rbp
leaq 0x188(%rbx), %r14
leaq 0x20(%rsp), %r15
cmpq %rbp, %r13
je 0x2df82
movq (%r13), %rdx
movq %rdx, (%rsp)
movq 0x38(%rbx), %rsi
movq %r15, %rdi
callq 0x164ca
movq 0x28(%rsp), %r12
subq 0x20(%rsp), %r12
movq %r15, %rdi
callq 0x990e
cmpq $0x11, %r12
jb 0x2df7c
movq %r14, %rdi
movq %rsp, %rsi
callq 0x171da
addq $0x8, %r13
jmp 0x2df40
leaq 0x8(%rsp), %rdi
callq 0x990e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2df9d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x990e
movq %rbx, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
leaq 0x20(%rbx), %rsi
leaq 0x68(%rbx), %rdi
callq 0x22652
movq 0xf8(%rbx), %rax
cmpq %rax, 0x100(%rbx)
je 0x2e1ed
movq %rax, 0x100(%rbx)
movq 0x110(%rbx), %rax
cmpq %rax, 0x118(%rbx)
je 0x2e204
movq %rax, 0x118(%rbx)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movb $0x1, %bpl
testb %al, %al
jne 0x2e240
movq %rbx, %rdi
callq 0x2e252
cmpb $0x1, 0x140(%rbx)
jne 0x2e23e
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rbx), %rdi
movl 0x8(%rdi), %eax
cmpl 0xc(%rdi), %eax
jl 0x2e208
jmp 0x2e240
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_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x80(%rdi), %r12
movq 0x88(%rdi), %r13
addq $0xc8, %r14
cmpq %r13, %r12
je 0x2eae5
movq (%r12), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2f019
testb %al, %al
jne 0x2eadf
addq $0x8, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2ea4f
testb %al, %al
jne 0x2eae5
addq $0x8, %r12
jmp 0x2eab4
cmpq %r13, %r12
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x80(%rdi), %r15
movq 0x88(%rdi), %rbx
movq %rsp, %r12
movq %rsi, 0x10(%rsp)
movq %rsi, (%r12)
movq %rbx, 0x8(%rsp)
subq %r15, %rbx
movq %rbx, %rbp
sarq $0x5, %rbp
testq %rbp, %rbp
jle 0x2ef48
movq %r12, %rdi
movq %r15, %rsi
callq 0x3151e
testb %al, %al
jne 0x2ef80
leaq 0x8(%r15), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x3151e
testb %al, %al
jne 0x2efa6
leaq 0x10(%r15), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x3151e
testb %al, %al
jne 0x2efa6
leaq 0x18(%r15), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x3151e
testb %al, %al
jne 0x2efa6
addq $0x20, %r15
decq %rbp
addq $-0x20, %rbx
jmp 0x2eee6
sarq $0x3, %rbx
cmpq $0x1, %rbx
je 0x2ef90
cmpq $0x2, %rbx
je 0x2ef71
cmpq $0x3, %rbx
jne 0x2ef85
movq %rsp, %rdi
movq %r15, %rsi
callq 0x3151e
testb %al, %al
jne 0x2ef80
addq $0x8, %r15
movq %rsp, %rdi
movq %r15, %rsi
callq 0x3151e
testb %al, %al
je 0x2ef8c
movq %r15, %r13
jmp 0x2efa6
movq 0x8(%rsp), %r13
jmp 0x2efa6
addq $0x8, %r15
movq %rsp, %rdi
movq %r15, %rsi
callq 0x3151e
testb %al, %al
movq 0x8(%rsp), %r13
cmovneq %r15, %r13
cmpq 0x88(%r14), %r13
je 0x2efc2
movq (%r13), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2afcf(%rip), %rdi     # 0x59f98
leaq 0xe8c4(%rip), %rsi      # 0x3d894
callq 0x63a0
leaq 0xe8ca(%rip), %rsi      # 0x3d8a6
movq %rax, %rdi
callq 0x63a0
leaq 0xe8e1(%rip), %rsi      # 0x3d8cc
movq %rax, %rdi
callq 0x63a0
movq 0x10(%rsp), %rcx
movl (%rcx), %esi
movq %rax, %rdi
callq 0x6630
leaq 0xb55a(%rip), %rsi      # 0x3a563
movq %rax, %rdi
callq 0x63a0
pushq $0x1
popq %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq 0x128(%rsi), %rax
cmpq 0x130(%rsi), %rax
je 0x2f436
movq %rdx, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r8, %rsi
callq 0x15d3a
movq 0x128(%r12), %r14
movq 0x130(%r12), %r15
leaq 0x18(%rsp), %rbp
cmpq %r15, %r14
je 0x2f409
movq (%r14), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1aca4
addq $0x8, %r14
jmp 0x2f3e7
movq 0x38(%r12), %rsi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
movq (%rsi), %rax
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movq 0x10(%rsp), %rcx
callq *0x20(%rax)
leaq 0x20(%rsp), %rdi
callq 0x990e
jmp 0x2f448
movq 0x38(%r12), %rsi
movq 0x8(%rdx), %rdx
movq (%rsi), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f45c
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x990e
movq %rbx, %rdi
callq 0x6650
nop