LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jaxonwang[P]suffixtree/main.cc
// Function: SuffixTreeNaive::build()
void build() {
    for (size_t i = 0; i <= textlen; i++) {
      int j = i;
      internal_node_ptr current_node = root;

      while (true) { // will eventually create a leaf
        CharT current_char = text[j];

        auto &nextedge_ptr = current_node->next_edge(current_char);
        if (!nextedge_ptr) {
          new_leaf(current_node, j, textlen);
          goto end_insert_i;
        }

        size_t start = nextedge_ptr->start_position();
        size_t end = nextedge_ptr->end_position();
        for (; start <= end; start++, j++) {
          if (text[start] != text[j]) {
            auto new_node = break_edge(current_node, current_char, start - 1);
            new_leaf(new_node, j, textlen); // include the term symbol
            goto end_insert_i;
          }
        }
        current_node = dynamic_cast<internal_node_ptr>(
            current_node->next_node(current_char));
        if (!current_node)
          throw std::logic_error("Goes to Leaf!");
      }

    end_insert_i:;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x20(%rdi), %rbx
xorl %ecx, %ecx
movq %rbx, -0x40(%rbp)
movq 0x28(%r14), %rax
movq %rax, -0x30(%rbp)
movq %rcx, -0x48(%rbp)
movl %ecx, -0x34(%rbp)
movslq -0x34(%rbp), %r15
movq %r14, %rbx
movq (%r14), %rcx
movsbl (%rcx,%r15), %r12d
movq %rax, %rdi
movl %r12d, %esi
callq 0x302c
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2979
movq %rax, %r14
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r13
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpq %rax, %r13
movq %rbx, %r14
ja 0x28fc
movq (%r14), %rcx
movb (%rcx,%r13), %dl
cmpb (%rcx,%r15), %dl
jne 0x2938
incq %r13
incq %r15
cmpq %rax, %r13
jbe 0x28e3
movl %r15d, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movl %r12d, %esi
callq 0x3374
testq %rax, %rax
je 0x2994
movq %rax, %rdi
leaq 0x5325(%rip), %rsi      # 0x7c40
leaq 0x5346(%rip), %rdx      # 0x7c68
xorl %ecx, %ecx
callq 0x21b0
movq %rax, -0x30(%rbp)
testq %rax, %rax
jne 0x289d
jmp 0x299c
decq %r13
movq %r14, %rdi
leaq -0x30(%rbp), %rsi
movl %r12d, %edx
movq %r13, %rcx
callq 0x3172
movq %rax, -0x50(%rbp)
movq %r14, %rdi
leaq -0x50(%rbp), %rsi
movq %r15, %rdx
movq -0x40(%rbp), %rbx
movq %rbx, %rcx
callq 0x307c
movq -0x48(%rbp), %rcx
incq %rcx
cmpq (%rbx), %rcx
jbe 0x288e
jmp 0x2985
movq %rbx, %r14
movq %rbx, %rdi
leaq -0x30(%rbp), %rsi
jmp 0x2958
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $0x0, -0x30(%rbp)
movl $0x10, %edi
callq 0x20b0
movq %rax, %rbx
leaq 0x26f3(%rip), %rsi      # 0x50a3
movq %rax, %rdi
callq 0x2200
movq 0x5621(%rip), %rsi      # 0x7fe0
movq 0x5602(%rip), %rdx      # 0x7fc8
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O3/jaxonwang[P]suffixtree/main.cc
// Function: SuffixTreeImpl::build()
void build() { // S[j,i)
    internal_node_ptr longest_node = root;
    internal_node_ptr node_to_start = longest_node;

    size_type j_start_with = 0;
    size_type start_depth = 0;

    for (size_type i = 0; i <= textlen; i++) {
      leaf_end_pos = i;
      internal_node_ptr node_to_update_suffix_link = nullptr;

      // find the depth of the longest_node

      for (size_type j = j_start_with; j <= i; j++) {

        internal_node_ptr stop_node;
        internal_node_ptr suffix_link_node;
        size_type travel_depth;
        auto ret =
            travel_down_and_extend(node_to_start, j + start_depth, i, stop_node,
                                   suffix_link_node, travel_depth);

        if (node_to_update_suffix_link) {
          // set suffix link
          node_to_update_suffix_link->set_suffix_link(suffix_link_node);
        }

        if (ret == ExtensionType::newnode) { // need to specify suffix link must
                                             // be updated
          node_to_update_suffix_link = suffix_link_node;
        } else {
          node_to_update_suffix_link = nullptr;
        }

        if (ret != ExtensionType::extendleaf) { // new leaf is created
          j_start_with = j + 1;
          node_to_start = stop_node->get_suffix_link(); // next to start
          start_depth += (stop_node == root) ? 0 : travel_depth - 1;
        } else { // no need for the future extend , since they must be extesion
                 // type 3
          break;
        }
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rax
leaq -0x38(%rbp), %rcx
movq %rax, (%rcx)
xorl %r14d, %r14d
xorl %r13d, %r13d
xorl %r15d, %r15d
movq %r13, 0x48(%rbx)
cmpq %r13, %r14
ja 0x2a86
xorl %r12d, %r12d
leaq (%r14,%r15), %rdx
leaq -0x40(%rbp), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
leaq -0x38(%rbp), %rsi
movq %r13, %rcx
leaq -0x48(%rbp), %r8
leaq -0x30(%rbp), %r9
callq 0x3c56
testq %r12, %r12
je 0x2a47
movq -0x30(%rbp), %rcx
movq %rcx, 0x78(%r12)
cmpl $0x2, %eax
je 0x2a86
movl $0x0, %r12d
cmpl $0x1, %eax
jne 0x2a5b
movq -0x30(%rbp), %r12
incq %r14
movq -0x48(%rbp), %rax
movq 0x78(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq -0x40(%rbp), %rcx
decq %rcx
cmpq 0x28(%rbx), %rax
movl $0x0, %eax
cmoveq %rax, %rcx
addq %rcx, %r15
cmpq %r13, %r14
jbe 0x2a16
incq %r13
cmpq 0x20(%rbx), %r13
jbe 0x2a0a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jaxonwang[P]suffixtree/main.cc
// Function: NonLeaf::next_edge(char)
edge_ptr &next_edge(const CharT c) {
    static edge_ptr empty_edge{};
    if (adj_edges.count(c))
      return adj_edges[c];
    return empty_edge;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb %sil, -0x9(%rbp)
movb 0x5149(%rip), %al       # 0x8188
testb %al, %al
je 0x3074
addq $0x40, %rbx
leaq -0x9(%rbp), %rsi
movq %rbx, %rdi
callq 0x33b2
testq %rax, %rax
je 0x3066
leaq -0x9(%rbp), %rsi
movq %rbx, %rdi
callq 0x3416
jmp 0x306d
leaq 0x5113(%rip), %rax      # 0x8180
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x22e4
jmp 0x3043
nop
// File: /workspace/github_cpp_makefile_star2_O3/jaxonwang[P]suffixtree/main.cc
// Function: SuffixTreeBase::new_leaf(InternalNode*&, unsigned long, unsigned long const&)
void new_leaf(internal_node_ptr &current_node, const size_type start_pos,
                const size_type &end_pos) {
    const CharT c = text[start_pos];
    current_node->adj_edges[c] =
        std::unique_ptr<Edge>{new LeafEdge{start_pos, end_pos}};

    std::unique_ptr<Leaf> newleaf_ptr{new Leaf{}};
    current_node->children[c] = newleaf_ptr.get();
    node_holder.push_back(move(newleaf_ptr));
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movb (%rax,%rdx), %al
leaq -0x29(%rbp), %rcx
movb %al, (%rcx)
movl $0x18, %edi
callq 0x21a0
movq %rax, %r15
leaq 0x4bf7(%rip), %rax      # 0x7cb0
movq %rax, (%r15)
movq %r13, 0x8(%r15)
movq %r12, 0x10(%r15)
movq (%r14), %rdi
addq $0x40, %rdi
leaq -0x29(%rbp), %rsi
callq 0x3416
movq (%rax), %rdi
movq %r15, (%rax)
testq %rdi, %rdi
je 0x30e5
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x10, %edi
callq 0x21a0
movq %rax, %r15
leaq 0x4c77(%rip), %rax      # 0x7d70
movq %rax, (%r15)
movq $0x0, 0x8(%r15)
movq (%r14), %rdi
addq $0x8, %rdi
leaq -0x29(%rbp), %rsi
callq 0x394e
movq %r15, (%rax)
addq $0x30, %rbx
leaq -0x38(%rbp), %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0x2eb0
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x3139
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x3169
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x3169
jmp 0x315e
movq %rax, %rbx
movq %r15, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O3/jaxonwang[P]suffixtree/main.cc
// Function: LeafEdge::break_edge(unsigned long) const
virtual std::pair<edge_ptr, edge_ptr>
  break_edge(const size_type pos) const override {
    if (pos < start_pos || pos >= end_pos)
      throw std::logic_error("bad pos");
    auto new_first = edge_ptr{new InternalEdge(start_pos, pos)};
    auto new_second = edge_ptr{new LeafEdge(pos + 1, end_pos)};
    return make_pair(move(new_first), move(new_second));
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %r13
cmpq %rdx, %r13
ja 0x37f8
movq %rdx, %r14
movq 0x10(%rsi), %r12
cmpq %rdx, (%r12)
jbe 0x37f8
movq %rdi, %rbx
movl $0x18, %edi
callq 0x21a0
movq %rax, %r15
leaq 0x4563(%rip), %rax      # 0x7d18
movq %rax, (%r15)
movq %r13, 0x8(%r15)
movq %r14, 0x10(%r15)
movl $0x18, %edi
callq 0x21a0
incq %r14
leaq 0x44dc(%rip), %rcx      # 0x7cb0
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %r15, (%rbx)
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20b0
movq %rax, %rbx
leaq 0x18a5(%rip), %rsi      # 0x50b1
movq %rax, %rdi
callq 0x2200
movq 0x47c5(%rip), %rsi      # 0x7fe0
movq 0x47a6(%rip), %rdx      # 0x7fc8
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
movq %r15, %rdi
callq 0x2180
jmp 0x3842
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/solver/hca.h
// Function: HCA::logStr[abi:cxx11]()
std::string logStr() {
    std::string str;
    str += "[solver] type:HCA\n";
    str += Solver::logStr();
    return str;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x3ce56(%rip), %rsi     # 0x4856f
callq 0x6690
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3f4ea
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6120
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb755
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb787
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
jmp 0xb787
jmp 0xb784
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xb79a
movq (%r15), %rsi
incq %rsi
callq 0x6380
movq %r14, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/agent/agent.cpp
// Function: Agent::Agent()
Agent::Agent() : id(cntId) {
  ++cntId;
  g = nullptr;
  tau = nullptr;
  updated = false;
  beforeNode = nullptr;
}

// Assembly:
movl 0x4964e(%rip), %eax     # 0x627bc
movl %eax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x30(%rdi)
incl %eax
movl %eax, 0x49637(%rip)     # 0x627bc
movb $0x0, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
movups %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/agent/agent.cpp
// Function: Agent::Agent(Node*)
Agent::Agent(Node* _v) : id(cntId) {
  ++cntId;
  g = nullptr;
  tau = nullptr;
  v = nullptr;
  setNode(_v);
  updated = false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x4961c(%rip), %eax     # 0x627bc
movl %eax, (%rdi)
leaq 0x20(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x30(%rdi)
incl %eax
movl %eax, 0x49601(%rip)     # 0x627bc
movq %rcx, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
callq 0x191f2
movb $0x0, 0x38(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
testq %rdi, %rdi
je 0x191e9
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x6380
movq %r14, %rdi
callq 0x6620
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/agent/agent.cpp
// Function: Agent::setNode(Node*)
void Agent::setNode(Node* _v) {
  // error check
  if (v != nullptr) {
    auto neigh = v->getNeighbor();
    if (!(_v == v || inArray(_v, neigh))) {
      std::cout << "error@Agent, set invalid node, from "
                << v->getId() << " to " << _v->getId() << std::endl;
      std::exit(1);
    }
  }

  beforeNode = v;
  v = _v;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x19257
addq $0x8, %rsi
leaq 0x8(%rsp), %rdi
callq 0x19aae
cmpq %rbx, 0x8(%r14)
je 0x1923a
leaq 0x20(%rsp), %rdx
movq %rbx, (%rdx)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x19b2e
cmpq 0x10(%rsp), %rax
je 0x19269
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x19251
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq 0x8(%r14), %rax
jmp 0x19259
xorl %eax, %eax
movq %rax, 0x40(%r14)
movq %rbx, 0x8(%r14)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x48d38(%rip), %rdi     # 0x61fa8
leaq 0x3021a(%rip), %rsi     # 0x49491
movl $0x24, %edx
callq 0x63f0
movq 0x8(%r14), %rax
movl (%rax), %esi
movq 0x48d1a(%rip), %rdi     # 0x61fa8
callq 0x6610
movq %rax, %r14
leaq 0x3256d(%rip), %rsi     # 0x4b80a
movl $0x4, %edx
movq %rax, %rdi
callq 0x63f0
movl (%rbx), %esi
movq %r14, %rdi
callq 0x6610
movq %rax, %rdi
callq 0x61c0
movl $0x1, %edi
callq 0x6440
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x192e0
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/agent/agent.cpp
// Function: Agent::updateHist()
void Agent::updateHist() {
  AgentStatus* s = new AgentStatus;
  s->v = v;
  if (hasGoal()) {
    s->g = g;
  } else {
    s->g = nullptr;
  }
  if (hasTask()) {
    s->tau = tau;
  } else {
    s->tau = nullptr;
  }
  hist.push_back(s);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x18, %edi
callq 0x6370
movq %rax, 0x8(%rsp)
movups 0x8(%rbx), %xmm0
movups %xmm0, (%rax)
movq 0x18(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x28(%rbx), %rsi
cmpq 0x30(%rbx), %rsi
je 0x1937a
movq %rax, (%rsi)
addq $0x8, 0x28(%rbx)
jmp 0x1938b
addq $0x20, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x19bda
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/graph/graph.cpp
// Function: Graph::~Graph()
Graph::~Graph() {
  for (auto v : nodes) delete v;
  nodes.clear();
  for (auto p : knownPaths) delete p.second;
  knownPaths.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x476a1(%rip), %rax     # 0x61590
movq %rax, (%rdi)
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %r12
cmpq %r12, %r15
je 0x19f40
movq (%r15), %r14
testq %r14, %r14
je 0x19f1c
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x19f1c
movq 0x18(%r14), %rsi
subq %rdi, %rsi
callq 0x6380
movl $0x28, %esi
movq %r14, %rdi
callq 0x6380
addq $0x8, %r15
cmpq %r12, %r15
jne 0x19eff
movq 0x10(%rbx), %rax
cmpq %rax, 0x18(%rbx)
je 0x19f40
movq %rax, 0x18(%rbx)
movq 0x38(%rbx), %r12
testq %r12, %r12
je 0x19fbe
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r14
movq %r13, 0x8(%rsp)
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0xb810
movq 0x28(%r12), %r15
movq %r15, 0x28(%rsp)
testq %r15, %r15
je 0x19f91
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x19f91
movq 0x20(%r15), %rsi
subq %rdi, %rsi
callq 0x6380
movl $0x28, %esi
movq %r15, %rdi
callq 0x6380
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x19fb5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6380
movq (%r12), %r12
testq %r12, %r12
jne 0x19f53
leaq 0x28(%rbx), %r14
movq %r14, %rdi
callq 0x1b874
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x19fe5
movq 0x90(%rbx), %rsi
subq %rdi, %rsi
callq 0x6380
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x19ffa
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x6380
movq %r14, %rdi
callq 0x1b84e
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1a017
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x6380
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0xb6e4
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/graph/graph.cpp
// Function: Graph::getNode(int)
Node* Graph::getNode(int id) {
  auto itr = std::find_if(nodes.begin(), nodes.end(),
                          [id](Node* v){ return v->getId() == id; });
  // error check
  if (itr == nodes.end()) {
    std::cout << "error@Graph::getNode, "
              << "node index is over, " << id << "\n";
    std::exit(1);
  }

  return *itr;
}

// Assembly:
pushq %rbx
movl %esi, %ebx
movq 0x10(%rdi), %rdx
movq 0x18(%rdi), %rax
movq %rax, %rdi
subq %rdx, %rdi
movq %rdi, %rsi
sarq $0x5, %rsi
testq %rsi, %rsi
jle 0x1a090
andq $-0x20, %rdi
movq %rdi, %rcx
addq %rdx, %rcx
incq %rsi
addq $0x10, %rdx
movq -0x10(%rdx), %rdi
cmpl %ebx, (%rdi)
je 0x1a0cd
movq -0x8(%rdx), %rdi
cmpl %ebx, (%rdi)
je 0x1a0d3
movq (%rdx), %rdi
cmpl %ebx, (%rdi)
je 0x1a0dd
movq 0x8(%rdx), %rdi
cmpl %ebx, (%rdi)
je 0x1a0d9
decq %rsi
addq $0x20, %rdx
cmpq $0x1, %rsi
jg 0x1a05c
movq %rax, %rdi
subq %rcx, %rdi
jmp 0x1a093
movq %rdx, %rcx
sarq $0x3, %rdi
cmpq $0x1, %rdi
je 0x1a0bf
cmpq $0x2, %rdi
je 0x1a0b4
cmpq $0x3, %rdi
jne 0x1a0e7
movq (%rcx), %rdx
cmpl %ebx, (%rdx)
je 0x1a0c8
addq $0x8, %rcx
movq (%rcx), %rdx
cmpl %ebx, (%rdx)
je 0x1a0c8
addq $0x8, %rcx
movq (%rcx), %rdx
cmpl %ebx, (%rdx)
cmovneq %rax, %rcx
movq %rcx, %rdx
jmp 0x1a0dd
addq $-0x10, %rdx
jmp 0x1a0dd
addq $-0x8, %rdx
jmp 0x1a0dd
addq $0x8, %rdx
cmpq %rax, %rdx
je 0x1a0e7
movq (%rdx), %rax
popq %rbx
retq
movq 0x47eba(%rip), %rdi     # 0x61fa8
leaq 0x2f41b(%rip), %rsi     # 0x49510
callq 0x6360
leaq 0x2f426(%rip), %rsi     # 0x49527
movq %rax, %rdi
callq 0x6360
movq %rax, %rdi
movl %ebx, %esi
callq 0x6610
leaq 0x2e449(%rip), %rsi     # 0x48563
movq %rax, %rdi
callq 0x6360
movl $0x1, %edi
callq 0x6440
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/graph/graph.cpp
// Function: Graph::getKey[abi:cxx11](Node*, Node*)
std::string Graph::getKey(Node* s, Node* g) {
  int sIndex = getNodeIndex(s);
  int gIndex = getNodeIndex(g);
  std::string key = "";
  key += std::to_string(sIndex);
  key += "-";
  key += std::to_string(gIndex);
  return key;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x4(%rdx), %r15d
movl 0x4(%rcx), %r14d
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
leaq 0x2d8ae(%rip), %rdx     # 0x48564
movq %rdx, %rsi
callq 0xb8a6
movl %r15d, %ebp
negl %ebp
cmovsl %r15d, %ebp
movl $0x1, %r12d
cmpl $0xa, %ebp
jb 0x1ad1b
movl $0x4, %r12d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x1ad12
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x1ad18
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x1ad1b
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r12d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x1acdf
addl $-0x3, %r12d
jmp 0x1ad1b
addl $-0x2, %r12d
jmp 0x1ad1b
decl %r12d
shrl $0x1f, %r15d
leal (%r12,%r15), %esi
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rsp, %rdi
movl $0x2d, %edx
callq 0x6410
addq (%rsp), %r15
movq %r15, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0xb7a2
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6120
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1ad71
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
leaq 0x310df(%rip), %rsi     # 0x4be57
movq %rbx, %rdi
callq 0x6690
movl %r14d, %ebp
negl %ebp
cmovsl %r14d, %ebp
movl $0x1, %r15d
cmpl $0xa, %ebp
jb 0x1addd
movl $0x4, %r15d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x1add4
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x1adda
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x1addd
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r15d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x1ada1
addl $-0x3, %r15d
jmp 0x1addd
addl $-0x2, %r15d
jmp 0x1addd
decl %r15d
shrl $0x1f, %r14d
leal (%r15,%r14), %esi
movq %rsp, %rdi
movq %r13, (%rdi)
movl $0x2d, %edx
callq 0x6410
addq (%rsp), %r14
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0xb7a2
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6120
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1ae2d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ae45
jmp 0x1ae60
jmp 0x1ae60
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1ae63
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6380
jmp 0x1ae63
movq %rax, %r14
movq (%rbx), %rdi
cmpq 0x20(%rsp), %rdi
je 0x1ae7d
movq 0x20(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x6380
movq %r14, %rdi
callq 0x6620
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/graph/pd.cpp
// Function: PD::setStartGoal()
void PD::setStartGoal() {
  // initialization
  starts.clear();
  goals.clear();

  // update starts
  starts = endpoints;
}

// Assembly:
movq %rdi, %rsi
movq 0x68(%rdi), %rax
cmpq %rax, 0x70(%rdi)
je 0x1dc2d
movq %rax, 0x70(%rsi)
leaq 0x68(%rsi), %rdi
movq 0x80(%rsi), %rax
cmpq %rax, 0x88(%rsi)
je 0x1dc48
movq %rax, 0x88(%rsi)
addq $0xf0, %rsi
jmp 0x1b2e0
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/graph/pd.cpp
// Function: PD::getRandomStartGoal(int)
Paths PD::getRandomStartGoal(int num) {
  if (num > nodes.size()) {
    std::cout << "error@PD::getStartGoal, over node size, "
              << num << "\n";
    std::exit(1);
  }

  Paths points;
  Nodes ends(starts.size());
  std::copy(starts.begin(), starts.end(), ends.begin());
  std::shuffle(ends.begin(), ends.end(), *MT);
  for (int i = 0; i < num; ++i) points.push_back({ ends[i] });

  return points;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movslq %edx, %rax
movq 0x18(%rsi), %rcx
subq 0x10(%rsi), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jb 0x1dd61
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x70(%rsi), %rsi
subq 0x68(%r14), %rsi
sarq $0x3, %rsi
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x1b5a2
movq 0x68(%r14), %rsi
movq 0x70(%r14), %rdx
subq %rsi, %rdx
je 0x1dcc2
movq 0x10(%rsp), %rdi
callq 0x65b0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x60(%r14), %rdx
callq 0x1b62f
testl %ebp, %ebp
jle 0x1dd38
movl %ebp, %r13d
xorl %ebp, %ebp
leaq 0x30(%rsp), %r14
leaq 0x28(%rsp), %r15
leaq 0xf(%rsp), %r12
movq 0x10(%rsp), %rax
movq (%rax,%rbp,8), %rax
movq %rax, 0x28(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0xb484
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18c56
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1dd30
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
incq %rbp
cmpq %rbp, %r13
jne 0x1dced
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1dd4f
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x44240(%rip), %rdi     # 0x61fa8
leaq 0x2c29b(%rip), %rsi     # 0x4a00a
callq 0x6360
movq %rax, %rdi
movl %ebp, %esi
callq 0x6610
leaq 0x2a7de(%rip), %rsi     # 0x48563
movq %rax, %rdi
callq 0x6360
movl $0x1, %edi
callq 0x6440
jmp 0x1dd9e
movq %rax, %r14
jmp 0x1ddd4
movq %rax, %r14
jmp 0x1ddbd
movq %rax, %r14
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1ddbd
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1ddd4
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
callq 0xb508
movq %r14, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/graph/simplegrid.cpp
// Function: SimpleGrid::init()
void SimpleGrid::init() {
  setBasicParams();  // read w, h
  createNodes();     // create nodes, not edges
  createEdges();     // set neighbor
  setStartGoal();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1e86e
movq %rbx, %rdi
callq 0x1edda
movq %rbx, %rdi
callq 0x1f1c8
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x68(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/graph/simplegrid.cpp
// Function: SimpleGrid::getNewGoal(Node*)
Node* SimpleGrid::getNewGoal(Node* v) {
  Node* u;
  do {
    u = randomChoose(goals, MT);
  } while (u == v);
  return u;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x80(%rdi), %rcx
leaq 0x8(%rsp), %r15
movq 0x60(%r14), %rsi
movq 0x88(%r14), %rax
subq %rcx, %rax
shrq $0x3, %rax
decl %eax
movl $0x0, 0x8(%rsp)
movl %eax, 0xc(%rsp)
movq %r15, %rdi
movq %r15, %rdx
callq 0x1fc82
cltq
movq 0x80(%r14), %rcx
movq (%rcx,%rax,8), %rax
cmpq %rbx, %rax
je 0x1f9fb
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/graph/station.cpp
// Function: Station::setStartGoal()
void Station::setStartGoal() {
  // initialization
  starts.clear();
  goals.clear();

  // update starts
  for (auto st : stations) {
    for (auto v : st) {
      starts.push_back(v);
      goals.push_back(v);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x68(%rdi), %rax
cmpq %rax, 0x70(%rdi)
je 0x20579
movq %rax, 0x70(%rbx)
movq 0x80(%rbx), %rax
cmpq %rax, 0x88(%rbx)
je 0x20590
movq %rax, 0x88(%rbx)
movq 0xc8(%rbx), %r14
movq 0xd0(%rbx), %rax
movq %rax, 0x28(%rsp)
cmpq %rax, %r14
je 0x20666
leaq 0x68(%rbx), %rax
movq %rax, 0x30(%rsp)
leaq 0x80(%rbx), %r12
leaq 0x8(%rsp), %rbp
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x19aae
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %r15
cmpq %r15, %r13
je 0x20642
movq (%r13), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rbx), %rsi
cmpq 0x78(%rbx), %rsi
je 0x205fa
movq %rax, (%rsi)
addq $0x8, 0x70(%rbx)
jmp 0x20607
movq 0x30(%rsp), %rdi
movq %rbp, %rdx
callq 0x1c5cc
movq 0x88(%rbx), %rsi
cmpq 0x90(%rbx), %rsi
je 0x20629
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x88(%rbx)
jmp 0x20634
movq %r12, %rdi
movq %rbp, %rdx
callq 0x1c5cc
addq $0x8, %r13
cmpq %r15, %r13
jne 0x205dd
movq 0x10(%rsp), %r13
testq %r13, %r13
je 0x20657
movq 0x20(%rsp), %rsi
subq %r13, %rsi
movq %r13, %rdi
callq 0x6380
addq $0x18, %r14
cmpq 0x28(%rsp), %r14
jne 0x205c1
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2068f
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
callq 0x6620
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/graph/station.cpp
// Function: Station::getNewGoal(Node*)
Node* Station::getNewGoal(Node* v) {
  int vIn = -1;
  std::vector<int> cands;
  for (int i = 0; i < stations.size(); ++i) {
    cands.push_back(i);
    if (inArray(v, stations[i])) vIn = i;
  }

  int newSt;
  do {
    newSt = randomChoose(cands, MT);
  } while (newSt == vIn);

  return randomChoose(stations[newSt], MT);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x4(%rsp)
movq 0xc8(%rdi), %r12
xorl %eax, %eax
cmpq %r12, 0xd0(%rdi)
je 0x20dfb
movq %rsi, %r14
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x8(%rsp), %r13
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x20d7c
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x20d92
leaq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0x21698
movq 0xc8(%rbx), %r12
movslq 0x4(%rsp), %rax
leaq (%rax,%rax,2), %r15
movq %r14, 0x8(%rsp)
movq (%r12,%r15,8), %rdi
movq 0x8(%r12,%r15,8), %rsi
movq %r13, %rdx
callq 0x19b2e
leaq (%r12,%r15,8), %rcx
cmpq 0x8(%rcx), %rax
movslq 0x4(%rsp), %rax
cmovnel %eax, %ebp
incq %rax
movl %eax, 0x4(%rsp)
movq 0xc8(%rbx), %r12
movq 0xd0(%rbx), %rcx
subq %r12, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
cmpq %rax, %rcx
ja 0x20d63
movq 0x10(%rsp), %rax
jmp 0x20e00
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x8(%rsp), %r14
movq 0x60(%rbx), %rsi
movq 0x18(%rsp), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
decl %ecx
movl $0x0, 0x8(%rsp)
movl %ecx, 0xc(%rsp)
movq %r14, %rdi
movq %r14, %rdx
callq 0x1fc82
movslq %eax, %rcx
movq 0x10(%rsp), %rax
movslq (%rax,%rcx,4), %rcx
cmpl %ebp, %ecx
je 0x20e05
movq 0x60(%rbx), %rsi
movq 0xc8(%rbx), %rbx
leaq (%rcx,%rcx,2), %r14
movq 0x8(%rbx,%r14,8), %rax
subq (%rbx,%r14,8), %rax
shrq $0x3, %rax
decl %eax
leaq 0x8(%rsp), %rdi
movl $0x0, (%rdi)
movl %eax, 0x4(%rdi)
movq %rdi, %rdx
callq 0x1fc82
leaq (%rbx,%r14,8), %rcx
cltq
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x20e96
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20eac
jmp 0x20eac
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x20ec6
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq %rbx, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/problem/imapf.cpp
// Function: IMAPF::init()
void IMAPF::init() {
  taskSum = 0;
  taskSumStr = "0,";
  nodes = G->getNodes();

  // initial allocation
  for (auto a : A) {
    allocate(a);
    a->updateHist();
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl $0x0, 0x90(%rdi)
addq $0xb0, %rdi
movq 0xb8(%rbx), %rdx
leaq 0x286a1(%rip), %rcx     # 0x4a210
movl $0x2, %r8d
xorl %esi, %esi
callq 0x6560
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x19aae
movq 0x98(%rbx), %rdi
movq 0xa8(%rbx), %rsi
movaps (%r14), %xmm0
movups %xmm0, 0x98(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0xa8(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
testq %rdi, %rdi
je 0x21be5
subq %rdi, %rsi
callq 0x6380
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x21be5
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq 0x18(%rbx), %r15
movq 0x20(%rbx), %r12
cmpq %r12, %r15
je 0x21c0e
movq (%r15), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21d76
movq %r14, %rdi
callq 0x19340
addq $0x8, %r15
jmp 0x21bed
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/problem/imapf.cpp
// Function: IMAPF::allocate(Agent*)
void IMAPF::allocate(Agent* a) {
  Node* v = G->getNewGoal(a->getNode());
  Task* tau = new Task(v, timestep);
  a->setTask(tau);
  a->setGoal(a->getTask()->getG()[0]);
  T_OPEN.push_back(tau);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x8(%rsi), %rsi
movq (%rdi), %rax
callq *0x30(%rax)
movq %rax, %r12
movl $0x40, %edi
callq 0x6370
movq %rax, %r14
movl 0x8(%rbx), %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x4710a
movq %r14, 0x8(%rsp)
movq %r14, 0x18(%r15)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x19aae
movq (%r12), %rdi
movq (%rdi), %rax
movq %rax, 0x10(%r15)
movq 0x10(%r12), %rsi
subq %rdi, %rsi
callq 0x6380
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x21df8
movq %r14, (%rsi)
addq $0x8, 0x38(%rbx)
jmp 0x21e09
addq $0x30, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x19048
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x40, %esi
movq %r14, %rdi
callq 0x6380
movq %rbx, %rdi
callq 0x6620
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/problem/imapf.cpp
// Function: IMAPF::isSolved()
bool IMAPF::isSolved() {
  if (taskSum < taskLimit) return false;
  // check all tasks are completed or not
  for (int i = 0; i < taskLimit; ++i) {
    auto itr = std::find_if(T_CLOSE.begin(), T_CLOSE.end(),
                            [i] (Task* tau) { return tau->getId() == i; });
    if (itr == T_CLOSE.end()) return false;
  }
  return true;;
}

// Assembly:
movl 0x94(%rdi), %ecx
cmpl %ecx, 0x90(%rdi)
jge 0x21e3f
xorl %eax, %eax
retq
movb $0x1, %al
testl %ecx, %ecx
jle 0x21e3e
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x48(%rdi), %rdx
movq 0x50(%rdi), %rsi
movq %rsi, %rdi
subq %rdx, %rdi
movq %rdi, %r8
sarq $0x5, %r8
movq %rdi, %r9
andq $-0x20, %r9
addq %rdx, %r9
movq %rsi, %r10
subq %r9, %r10
leaq 0x1(%r8), %r11
leaq 0x10(%rdx), %rbx
xorl %ebp, %ebp
movq %rdi, %r15
movq %rdx, %r14
testq %r8, %r8
jle 0x21ecb
movq %rbx, %r14
movq %r11, %r15
movq -0x10(%r14), %r12
cmpl %ebp, 0x30(%r12)
je 0x21f08
movq -0x8(%r14), %r12
cmpl %ebp, 0x30(%r12)
je 0x21f0e
movq (%r14), %r12
cmpl %ebp, 0x30(%r12)
je 0x21f18
movq 0x8(%r14), %r12
cmpl %ebp, 0x30(%r12)
je 0x21f14
decq %r15
addq $0x20, %r14
cmpq $0x1, %r15
jg 0x21e8d
movq %r10, %r15
movq %r9, %r14
sarq $0x3, %r15
cmpq $0x1, %r15
je 0x21efb
cmpq $0x2, %r15
je 0x21eee
cmpq $0x3, %r15
jne 0x21f29
movq (%r14), %r15
cmpl %ebp, 0x30(%r15)
je 0x21f18
addq $0x8, %r14
movq (%r14), %r15
cmpl %ebp, 0x30(%r15)
je 0x21f18
addq $0x8, %r14
movq (%r14), %r15
cmpl %ebp, 0x30(%r15)
cmovneq %rsi, %r14
jmp 0x21f18
addq $-0x10, %r14
jmp 0x21f18
addq $-0x8, %r14
jmp 0x21f18
addq $0x8, %r14
cmpq %rsi, %r14
je 0x21f29
incl %ebp
cmpl %ecx, %ebp
jne 0x21e7c
jmp 0x21f2b
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/problem/imapf_fair.cpp
// Function: IMAPF_FAIR::init()
void IMAPF_FAIR::init() {
  taskSum = 0;

  // initial allocation
  for (auto a : A) {
    goalCounts.push_back(0);
    allocate(a);
    a->updateHist();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x0, 0x94(%rdi)
movq 0x18(%rdi), %r13
movq 0x20(%rdi), %rbp
cmpq %rbp, %r13
je 0x22a5f
movq %rdi, %rbx
leaq 0x98(%rdi), %r14
leaq 0x4(%rsp), %r15
movq (%r13), %r12
movl $0x0, 0x4(%rsp)
movq 0xa0(%rbx), %rsi
cmpq 0xa8(%rbx), %rsi
je 0x22a38
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xa0(%rbx)
jmp 0x22a43
movq %r14, %rdi
movq %r15, %rdx
callq 0x23392
movq %rbx, %rdi
movq %r12, %rsi
callq 0x22b8e
movq %r12, %rdi
callq 0x19340
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x22a09
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/problem/imapf_fair.cpp
// Function: IMAPF_FAIR::update()
void IMAPF_FAIR::update() {
  ++timestep;
  Agent* a;

  for (int i = 0; i < A.size(); ++i) {
    a = A[i];
    auto tau = a->getTask();
    if (tau) {
      tau->update(a->getNode());

      if (tau->completed()) {
        ++taskSum;
        goalCounts[i] += 1;
        tau->setEndTime(timestep);
        a->releaseTask();
        openToClose(tau, T_OPEN, T_CLOSE);
        allocate(a);
        a->goalUpdated(true);
      } else {
        a->goalUpdated(false);
      }
    } else {
      allocate(a);
    }
    a->updateHist();
  }
}

// Assembly:
incl 0x8(%rdi)
movq 0x18(%rdi), %rax
cmpq %rax, 0x20(%rdi)
je 0x22d88
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x48(%rdi), %rcx
movq %rcx, 0x8(%rsp)
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq (%rax,%r14,8), %r12
movq 0x18(%r12), %r13
testq %r13, %r13
je 0x22cfd
movq 0x8(%r12), %rsi
movq %r13, %rdi
callq 0x47282
movq %r13, %rdi
callq 0x47302
testb %al, %al
je 0x22d0a
incl 0x94(%rbx)
movq 0x98(%rbx), %rax
incl (%rax,%r14,4)
movl 0x8(%rbx), %esi
movq %r13, %rdi
callq 0x4730e
movq %r12, %rdi
callq 0x19392
movq %r13, 0x10(%rsp)
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
movq %r15, %rdx
callq 0x22864
cmpq 0x38(%rbx), %rax
je 0x22d46
movq %rax, %r13
movq %rax, %rbp
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x22d12
movq (%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x50(%rbx)
jmp 0x22d1f
movq %rbx, %rdi
movq %r12, %rsi
callq 0x22b8e
jmp 0x22d57
movb $0x0, 0x38(%r12)
jmp 0x22d57
movq 0x8(%rsp), %rdi
movq %rbp, %rdx
callq 0x19048
addq $0x8, %r13
movq 0x38(%rbx), %rdx
cmpq %rdx, %r13
je 0x22d3e
subq %r13, %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x65b0
movq 0x38(%rbx), %rdx
addq $-0x8, %rdx
movq %rdx, 0x38(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x22b8e
movb $0x1, 0x38(%r12)
movq %r12, %rdi
callq 0x19340
incq %r14
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0x22c79
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/problem/imapf_fair.cpp
// Function: IMAPF_FAIR::isSolved()
bool IMAPF_FAIR::isSolved() {
  if (taskSum < taskLimit * A.size()) return false;
  // check all tasks are completed or not
  auto itr = std::find_if(goalCounts.begin(), goalCounts.end(),
                          [&] (int i) { return i < taskLimit; });
  if (itr != goalCounts.end()) return false;
  return true;
}

// Assembly:
movslq 0x94(%rdi), %rax
movq 0x20(%rdi), %rdx
subq 0x18(%rdi), %rdx
movslq 0x90(%rdi), %rcx
sarq $0x3, %rdx
imulq %rcx, %rdx
cmpq %rax, %rdx
jbe 0x22db0
xorl %eax, %eax
retq
movq 0x98(%rdi), %rsi
movq 0xa0(%rdi), %rax
movq %rax, %r8
subq %rsi, %r8
movq %r8, %rdi
sarq $0x4, %rdi
testq %rdi, %rdi
jle 0x22e09
andq $-0x10, %r8
movq %r8, %rdx
addq %rsi, %rdx
incq %rdi
addq $0x8, %rsi
cmpl %ecx, -0x8(%rsi)
jl 0x22e40
cmpl %ecx, -0x4(%rsi)
jl 0x22e46
cmpl %ecx, (%rsi)
jl 0x22e50
cmpl %ecx, 0x4(%rsi)
jl 0x22e4c
decq %rdi
addq $0x10, %rsi
cmpq $0x1, %rdi
jg 0x22de1
movq %rax, %r8
subq %rdx, %r8
jmp 0x22e0c
movq %rsi, %rdx
sarq $0x2, %r8
cmpq $0x1, %r8
je 0x22e35
cmpq $0x2, %r8
je 0x22e2d
movq %rax, %rsi
cmpq $0x3, %r8
jne 0x22e50
cmpl %ecx, (%rdx)
jl 0x22e3b
addq $0x4, %rdx
cmpl %ecx, (%rdx)
jl 0x22e3b
addq $0x4, %rdx
cmpl %ecx, (%rdx)
cmovgeq %rax, %rdx
movq %rdx, %rsi
jmp 0x22e50
addq $-0x8, %rsi
jmp 0x22e50
addq $-0x4, %rsi
jmp 0x22e50
addq $0x4, %rsi
cmpq %rax, %rsi
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/problem/mapd.cpp
// Function: MAPD::isSolved()
bool MAPD::isSolved() {
  if (taskCnt >= taskNum && T_OPEN.empty()) {
    if (std::all_of(A.begin(), A.end(),
                    [](Agent* a) { return !a->hasTask(); })) {
      return true;
    }
  }
  return false;
}

// Assembly:
movl 0xc0(%rdi), %eax
cmpl 0xc4(%rdi), %eax
jl 0x23b8c
movq 0x30(%rdi), %rax
cmpq 0x38(%rdi), %rax
jne 0x23b8c
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
movq %rcx, %rdi
subq %rax, %rdi
movq %rdi, %rsi
sarq $0x5, %rsi
testq %rsi, %rsi
jle 0x23b2f
andq $-0x20, %rdi
movq %rdi, %rdx
addq %rax, %rdx
incq %rsi
addq $0x10, %rax
movq -0x10(%rax), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x23b77
movq -0x8(%rax), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x23b7d
movq (%rax), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x23b87
movq 0x8(%rax), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x23b83
decq %rsi
addq $0x20, %rax
cmpq $0x1, %rsi
jg 0x23aef
movq %rcx, %rdi
subq %rdx, %rdi
jmp 0x23b32
movq %rax, %rdx
sarq $0x3, %rdi
cmpq $0x1, %rdi
je 0x23b66
cmpq $0x2, %rdi
je 0x23b58
movb $0x1, %al
cmpq $0x3, %rdi
jne 0x23b8e
movq (%rdx), %rax
cmpq $0x0, 0x18(%rax)
jne 0x23b72
addq $0x8, %rdx
movq (%rdx), %rax
cmpq $0x0, 0x18(%rax)
jne 0x23b72
addq $0x8, %rdx
movq (%rdx), %rax
cmpq $0x0, 0x18(%rax)
cmoveq %rcx, %rdx
movq %rdx, %rax
jmp 0x23b87
addq $-0x10, %rax
jmp 0x23b87
addq $-0x8, %rax
jmp 0x23b87
addq $0x8, %rax
cmpq %rcx, %rax
je 0x23b8f
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/problem/mapd.cpp
// Function: MAPD::update()
void MAPD::update() {
  ++timestep;
  updateStatus();
  createTask();
  if (autoAssignment) autoAssign();
  for (auto a : A) a->updateHist();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
incl 0x8(%rdi)
callq 0x23bde
movq %rbx, %rdi
callq 0x23c84
cmpb $0x1, 0xcc(%rbx)
jne 0x23bba
movq %rbx, %rdi
callq 0x23e1c
movq 0x18(%rbx), %r14
movq 0x20(%rbx), %rbx
cmpq %rbx, %r14
je 0x23bd5
movq (%r14), %rdi
callq 0x19340
addq $0x8, %r14
jmp 0x23bc2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/problem/mapd.cpp
// Function: MAPD::createTask()
void MAPD::createTask() {
  if (taskCnt >= taskNum) return;

  int num;
  if (taskFrequency >= 1) {
    num = (int)taskFrequency;
  } else if (timestep % (int)(1 / taskFrequency) == 0) {
    num = 1;
  } else {
    num = 0;
  }

  Node *p, *d;

  for (int i = 0; i < num; ++i) {
    if (taskCnt < taskNum) {  // limit
      do {
        p = randomChoose(pickupNodes, MT);
        d = randomChoose(deliveryNodes, MT);
      } while (p == d);
      Task* tau = new Task(timestep);
      tau->addNode(p);  // pickup
      tau->addNode(d);  // delivery
      T_OPEN.push_back(tau);
      ++taskCnt;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0xc0(%rdi), %ecx
cmpl 0xc4(%rdi), %ecx
jge 0x23df5
movq %rdi, %rbx
movss 0xc8(%rdi), %xmm0
ucomiss 0x266ae(%rip), %xmm0    # 0x4a364
jae 0x23cd7
movss 0x266a4(%rip), %xmm1    # 0x4a364
divss %xmm0, %xmm1
cvttss2si %xmm1, %esi
movl 0x8(%rbx), %eax
cltd
idivl %esi
xorl %eax, %eax
testl %edx, %edx
sete %al
jmp 0x23cdb
cvttss2si %xmm0, %eax
testl %eax, %eax
jle 0x23df5
leaq 0x30(%rbx), %rdx
movq %rdx, 0x10(%rsp)
xorl %r14d, %r14d
movq %rsp, %r15
xorl %edx, %edx
movl %eax, 0x8(%rsp)
cmpl 0xc4(%rbx), %ecx
jge 0x23deb
movl %edx, 0xc(%rsp)
movq 0x60(%rbx), %rsi
movq 0x98(%rbx), %rax
subq 0x90(%rbx), %rax
shrq $0x3, %rax
decl %eax
movl %r14d, (%rsp)
movl %eax, 0x4(%rsp)
movq %r15, %rdi
movq %r15, %rdx
callq 0x1fc82
cltq
movq 0x90(%rbx), %rcx
movq (%rcx,%rax,8), %r12
movq 0x60(%rbx), %rsi
movq 0xb0(%rbx), %rax
subq 0xa8(%rbx), %rax
shrq $0x3, %rax
decl %eax
movl %r14d, (%rsp)
movl %eax, 0x4(%rsp)
movq %r15, %rdi
movq %r15, %rdx
callq 0x1fc82
cltq
movq 0xa8(%rbx), %rcx
movq (%rcx,%rax,8), %r13
cmpq %r13, %r12
je 0x23d08
movl $0x40, %edi
callq 0x6370
movq %rax, %rbp
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x470e0
movq %rbp, (%rsp)
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2473a
movq (%rsp), %rdi
movq %r13, %rsi
callq 0x2473a
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x23dc8
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x38(%rbx)
jmp 0x23dd5
movq 0x10(%rsp), %rdi
movq %r15, %rdx
callq 0x19048
movl 0xc0(%rbx), %ecx
incl %ecx
movl %ecx, 0xc0(%rbx)
movl 0x8(%rsp), %eax
movl 0xc(%rsp), %edx
incl %edx
cmpl %eax, %edx
jne 0x23cf8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x40, %esi
movq %rbp, %rdi
callq 0x6380
movq %rbx, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/problem/mapf.cpp
// Function: MAPF::update()
void MAPF::update() {
  ++timestep;

  for (auto a : A) {
    auto tau = a->getTask();
    if (tau) {  // if agent has a task
      tau->update(a->getNode());  // update task status
      if (tau->completed()) {  // if task is completed
        a->releaseTaskOnly();  // agent release task, not goal
        openToClose(tau, T_OPEN, T_CLOSE);
      }
    } else if (a->getNode() != a->getGoal()) {
      // create new task and assign
      Task* newTau = new Task(a->getGoal());
      a->setTask(newTau);
      a->setGoal(newTau->getG()[0]);
      T_OPEN.push_back(newTau);
    }
    a->updateHist();
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
incl 0x8(%rdi)
movq 0x18(%rdi), %r14
movq 0x20(%rdi), %r12
cmpq %r12, %r14
je 0x24d23
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x48(%rdi), %rax
movq %rax, 0x10(%rsp)
movq (%r14), %rbp
movq 0x8(%rbp), %rsi
movq 0x18(%rbp), %r15
testq %r15, %r15
je 0x24c5e
movq %r15, %rdi
callq 0x47282
movq %r15, %rdi
callq 0x47302
testb %al, %al
je 0x24d0e
movq %rbp, %rdi
callq 0x1939a
movq %r15, 0x20(%rsp)
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
leaq 0x20(%rsp), %rdx
callq 0x22864
cmpq 0x38(%rbx), %rax
je 0x24d0e
movq %rax, %r13
movq %rax, %r15
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x24cda
movq (%r15), %rax
movq %rax, (%rsi)
addq $0x8, 0x50(%rbx)
jmp 0x24ce7
cmpq 0x10(%rbp), %rsi
je 0x24d0e
movl $0x40, %edi
callq 0x6370
movq %rax, %r15
movq 0x10(%rbp), %rsi
movq %rax, %rdi
callq 0x47064
movq %r15, 0x8(%rsp)
movq %r15, 0x18(%rbp)
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x19aae
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq %rax, 0x10(%rbp)
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x6380
movq 0x38(%rbx), %rsi
cmpq 0x40(%rbx), %rsi
je 0x24cc9
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x38(%rbx)
jmp 0x24d0e
movq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x19048
jmp 0x24d0e
movq 0x10(%rsp), %rdi
movq %r15, %rdx
callq 0x19048
addq $0x8, %r13
movq 0x38(%rbx), %rdx
cmpq %rdx, %r13
je 0x24d06
subq %r13, %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x65b0
movq 0x38(%rbx), %rdx
addq $-0x8, %rdx
movq %rdx, 0x38(%rbx)
movq %rbp, %rdi
callq 0x19340
addq $0x8, %r14
cmpq %r12, %r14
jne 0x24be9
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x40, %esi
movq %r15, %rdi
callq 0x6380
movq %rbx, %rdi
callq 0x6620
// File: /workspace/github_cpp_makefile_star2_O3/Kei18[P]pibt/./src/problem/problem.cpp
// Function: Problem::~Problem()
Problem::~Problem() {
  for (auto a : A) delete a;
  for (auto t : T_OPEN) delete t;
  for (auto t : T_CLOSE) delete t;
  A.clear();
  T_OPEN.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3c1f2(%rip), %rax     # 0x619f0
movq %rax, (%rdi)
movq 0x18(%rdi), %r15
movq 0x20(%rdi), %r12
cmpq %r12, %r15
je 0x25831
movq (%r15), %r14
testq %r14, %r14
je 0x2581e
movq %r14, %rdi
callq 0x192e8
movl $0x48, %esi
movq %r14, %rdi
callq 0x6380
addq $0x8, %r15
jmp 0x25809
movq 0x30(%rbx), %r15
movq 0x38(%rbx), %r12
cmpq %r12, %r15
je 0x25861
movq (%r15), %r14
testq %r14, %r14
je 0x2584e
movq %r14, %rdi
callq 0x47238
movl $0x40, %esi
movq %r14, %rdi
callq 0x6380
addq $0x8, %r15
jmp 0x25839
movq 0x48(%rbx), %r15
movq 0x50(%rbx), %r12
cmpq %r12, %r15
je 0x25891
movq (%r15), %r14
testq %r14, %r14
je 0x2587e
movq %r14, %rdi
callq 0x47238
movl $0x40, %esi
movq %r14, %rdi
callq 0x6380
addq $0x8, %r15
jmp 0x25869
movq 0x18(%rbx), %rax
cmpq %rax, 0x20(%rbx)
je 0x2589f
movq %rax, 0x20(%rbx)
movq 0x30(%rbx), %rax
cmpq %rax, 0x38(%rbx)
je 0x258ad
movq %rax, 0x38(%rbx)
movq 0x70(%rbx), %rdi
leaq 0x80(%rbx), %rax
cmpq %rax, %rdi
je 0x258c8
movq (%rax), %rsi
incq %rsi
callq 0x6380
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x258dd
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x6380
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x258f2
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x6380
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x25912
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6380
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2b35f
cmpq 0x8(%rbx), %rax
je 0x2667f
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x2aa02
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2b4b2
popq %rbx
popq %r14
popq %r15
retq
nop