LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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), %r12
cmpq %rdx, %r12
ja 0x36d2
movq %rdx, %r14
movq 0x10(%rsi), %r13
cmpq %rdx, (%r13)
jbe 0x36d2
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x2170
movq %rax, %r15
leaq 0x3687(%rip), %rax      # 0x6d18
movq %rax, (%r15)
movq %r12, 0x8(%r15)
movq %r14, 0x10(%r15)
pushq $0x18
popq %rdi
callq 0x2170
incq %r14
leaq 0x3602(%rip), %rcx      # 0x6cb0
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
movq %r13, 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
pushq $0x10
popq %rdi
callq 0x20b0
movq %rax, %rbx
leaq 0x9a3(%rip), %rsi       # 0x4087
movq %rax, %rdi
callq 0x21d0
movq 0x38ed(%rip), %rsi      # 0x6fe0
movq 0x38c6(%rip), %rdx      # 0x6fc0
movq %rbx, %rdi
callq 0x2250
movq %rax, %r14
movq %r15, %rdi
callq 0x2150
jmp 0x371a
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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 %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 0x30e7f(%rip), %rsi     # 0x3a56f
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 0x9738
jmp 0x9735
movq %rax, %r14
movq %rbx, %rdi
callq 0x61d0
movq %r14, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/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 0x44f92(%rip), %eax     # 0x5a7cc
movl %eax, (%rdi)
xorps %xmm0, %xmm0
andq $0x0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
incl %eax
movl %eax, 0x44f7c(%rip)     # 0x5a7cc
movb $0x0, 0x38(%rdi)
andq $0x0, 0x40(%rdi)
movups %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x44f61(%rip), %eax     # 0x5a7cc
movl %eax, (%rdi)
leaq 0x20(%rdi), %rbx
andq $0x0, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
incl %eax
movl %eax, 0x44f47(%rip)     # 0x5a7cc
movups %xmm0, 0x8(%rdi)
andq $0x0, 0x18(%rdi)
callq 0x158b4
movb $0x0, 0x38(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x15dae
movq %r14, %rdi
callq 0x6650
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1590c
addq $0x8, %rsi
leaq 0x8(%rsp), %rdi
callq 0x15d3a
cmpq %rbx, 0x8(%r14)
je 0x158fc
leaq 0x20(%rsp), %rdx
movq %rbx, (%rdx)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x15de1
cmpq 0x10(%rsp), %rax
je 0x1591e
leaq 0x8(%rsp), %rdi
callq 0x990e
movq 0x8(%r14), %rax
jmp 0x1590e
xorl %eax, %eax
movq %rax, 0x40(%r14)
movq %rbx, 0x8(%r14)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x44673(%rip), %rdi     # 0x59f98
leaq 0x25b65(%rip), %rsi     # 0x3b491
callq 0x63a0
movq 0x8(%r14), %rcx
movl (%rcx), %esi
movq %rax, %rdi
callq 0x6630
leaq 0x28025(%rip), %rsi     # 0x3d96b
movq %rax, %rdi
callq 0x63a0
movl (%rbx), %esi
movq %rax, %rdi
callq 0x6630
movq %rax, %rdi
callq 0x6200
pushq $0x1
popq %rdi
callq 0x6450
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x990e
movq %rbx, %rdi
callq 0x6650
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x63b0
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movups 0x8(%rbx), %xmm0
movups %xmm0, (%rax)
movq 0x18(%rbx), %rcx
movq %rcx, 0x10(%rax)
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x15ce4
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
leaq 0x43468(%rip), %rax     # 0x59590
movq %rax, (%rdi)
leaq 0x10(%rdi), %rbx
movq 0x10(%rdi), %r13
movq 0x18(%rdi), %rbp
pushq $0x28
popq %r15
cmpq %rbp, %r13
je 0x16164
movq (%r13), %r12
testq %r12, %r12
je 0x16153
leaq 0x8(%r12), %rdi
callq 0x990e
movq %r12, %rdi
movq %r15, %rsi
callq 0x63c0
addq $0x8, %r13
jmp 0x1613b
movq 0x10(%r14), %rax
cmpq %rax, 0x18(%r14)
je 0x16172
movq %rax, 0x18(%r14)
leaq 0x38(%r14), %rbp
movq %rsp, %r15
pushq $0x28
popq %r12
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x161ba
leaq 0x8(%rbp), %rsi
movq %r15, %rdi
callq 0x16f70
movq 0x20(%rsp), %r13
testq %r13, %r13
je 0x161a5
leaq 0x10(%r13), %rdi
callq 0x990e
movq %r13, %rdi
movq %r12, %rsi
callq 0x63c0
movq %r15, %rdi
callq 0x61d0
jmp 0x1617d
leaq 0x28(%r14), %r15
movq %r15, %rdi
callq 0x1745c
leaq 0x80(%r14), %rdi
callq 0x990e
addq $0x68, %r14
movq %r14, %rdi
callq 0x990e
movq %r15, %rdi
callq 0x17440
movq %rbx, %rdi
callq 0x990e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x95d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
movq 0x18(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
movq %rdx, %rsi
sarq $0x5, %rsi
testq %rsi, %rsi
jle 0x1624f
movq (%rax), %rdi
cmpl %ebx, (%rdi)
je 0x16296
movq 0x8(%rax), %rdi
cmpl %ebx, (%rdi)
je 0x16286
movq 0x10(%rax), %rdi
cmpl %ebx, (%rdi)
je 0x1628c
movq 0x18(%rax), %rdi
cmpl %ebx, (%rdi)
je 0x16292
addq $0x20, %rax
decq %rsi
addq $-0x20, %rdx
jmp 0x1621e
sarq $0x3, %rdx
cmpq $0x1, %rdx
je 0x1627b
cmpq $0x2, %rdx
je 0x16270
cmpq $0x3, %rdx
jne 0x162a0
movq (%rax), %rdx
cmpl %ebx, (%rdx)
je 0x16296
addq $0x8, %rax
movq (%rax), %rdx
cmpl %ebx, (%rdx)
je 0x16296
addq $0x8, %rax
movq (%rax), %rdx
cmpl %ebx, (%rdx)
cmovneq %rcx, %rax
jmp 0x16296
addq $0x8, %rax
jmp 0x16296
addq $0x10, %rax
jmp 0x16296
addq $0x18, %rax
cmpq %rcx, %rax
je 0x162a0
movq (%rax), %rax
popq %rbx
retq
movq 0x43cf1(%rip), %rdi     # 0x59f98
leaq 0x25224(%rip), %rsi     # 0x3b4d2
callq 0x63a0
leaq 0x2522f(%rip), %rsi     # 0x3b4e9
movq %rax, %rdi
callq 0x63a0
movq %rax, %rdi
movl %ebx, %esi
callq 0x6630
leaq 0x24290(%rip), %rsi     # 0x3a563
movq %rax, %rdi
callq 0x63a0
pushq $0x1
popq %rdi
callq 0x6450
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0x4(%rdx), %r14d
movl 0x4(%rcx), %ebp
leaq 0x23a3f(%rip), %rsi     # 0x3a564
movq %rsp, %rdx
callq 0x92b0
movq %rsp, %rdi
movl %r14d, %esi
callq 0x943e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x66c0
movq %rsp, %rdi
callq 0x61d0
leaq 0x27815(%rip), %rsi     # 0x3e367
movq %rbx, %rdi
callq 0x66a0
movq %rsp, %rdi
movl %ebp, %esi
callq 0x943e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x66c0
movq %rsp, %rdi
callq 0x61d0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x16b89
jmp 0x16b96
jmp 0x16b96
movq %rax, %r14
movq %rsp, %rdi
callq 0x61d0
jmp 0x16b99
movq %rax, %r14
movq %rbx, %rdi
callq 0x61d0
movq %r14, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/graph/graph.cpp
// Function: Graph::getRandomStartGoal(int)
Paths Graph::getRandomStartGoal(int num) {
  if (num > starts.size() || num > goals.size()) {
    std::cout << "error@Graph::getStartGoal, over node size" << "\n";
    std::exit(1);
  }

  Paths points;
  Nodes ss(starts.size());
  Nodes gs(goals.size());
  bool flg;

  std::copy(starts.begin(), starts.end(), ss.begin());
  std::copy(goals.begin(),  goals.end(), gs.begin());

  while (true) {
    points.clear();
    std::shuffle(ss.begin(), ss.end(), *MT);
    std::shuffle(gs.begin(), gs.end(), *MT);

    flg = true;
    for (int i = 0; i < num; ++i) {
      if (ss[i] != gs[i]) {
        points.push_back({ ss[i], gs[i] });
      } else {
        flg = false;
        break;
      }
    }

    if (flg) break;
  }

  return points;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
movslq %edx, %rax
movq 0x70(%rsi), %rsi
subq 0x68(%rbx), %rsi
sarq $0x3, %rsi
cmpq %rax, %rsi
jb 0x16e9b
movq 0x88(%rbx), %rcx
subq 0x80(%rbx), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jb 0x16e9b
movl %edx, %r14d
xorps %xmm0, %xmm0
movq 0x10(%rsp), %rax
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x17216
movq 0x88(%rbx), %rsi
subq 0x80(%rbx), %rsi
sarq $0x3, %rsi
leaq 0x18(%rsp), %rdi
leaq 0x60(%rsp), %rdx
callq 0x17216
movq 0x68(%rbx), %rsi
movq 0x70(%rbx), %rdx
subq %rsi, %rdx
je 0x16dad
movq 0x30(%rsp), %rdi
callq 0x65c0
movq 0x80(%rbx), %rsi
movq %rbx, 0x48(%rsp)
movq 0x88(%rbx), %rdx
subq %rsi, %rdx
je 0x16dcf
movq 0x18(%rsp), %rdi
callq 0x65c0
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
leaq 0x60(%rsp), %r12
leaq 0x50(%rsp), %r13
pushq $0x2
popq %rbp
leaq 0xf(%rsp), %r15
movq 0x10(%rsp), %rdi
callq 0x17268
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x48(%rsp), %rbx
movq 0x60(%rbx), %rdx
callq 0x17270
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x60(%rbx), %rdx
callq 0x17270
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0x16e73
movq 0x30(%rsp), %rax
movq (%rax,%rbx,8), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx,%rbx,8), %rax
je 0x16dea
movq %rax, 0x50(%rsp)
movq (%rcx,%rbx,8), %rax
movq %rax, 0x58(%rsp)
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x927a
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x15146
movq %r12, %rdi
callq 0x990e
incq %rbx
jmp 0x16e21
leaq 0x18(%rsp), %rdi
callq 0x990e
leaq 0x30(%rsp), %rdi
callq 0x990e
movq 0x10(%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x430f6(%rip), %rdi     # 0x59f98
leaq 0x24655(%rip), %rsi     # 0x3b4fe
callq 0x63a0
leaq 0x236ae(%rip), %rsi     # 0x3a563
movq %rax, %rdi
callq 0x63a0
pushq $0x1
popq %rdi
callq 0x6450
movq %rax, %r14
jmp 0x16eed
movq %rax, %r14
jmp 0x16ef7
jmp 0x16ed1
movq %rax, %r14
jmp 0x16ee3
movq %rax, %r14
leaq 0x60(%rsp), %rdi
callq 0x990e
leaq 0x18(%rsp), %rdi
callq 0x990e
leaq 0x30(%rsp), %rdi
callq 0x990e
movq 0x10(%rsp), %rdi
callq 0x92ec
movq %r14, %rdi
callq 0x6650
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/graph/grid.cpp
// Function: Grid::logStr[abi:cxx11]()
std::string Grid::logStr() {
  std::string str;
  str += "[graph] width:" + std::to_string(getW()) + "\n";
  str += "[graph] height:" + std::to_string(getH()) + "\n";
  return str;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
leaq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x943e
leaq 0x23140(%rip), %rsi     # 0x3bf98
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x941a
leaq 0x216f5(%rip), %rdx     # 0x3a563
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x93fb
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x48(%rsp), %rdi
callq 0x61d0
leaq 0x28(%rsp), %rdi
callq 0x61d0
leaq 0x8(%rsp), %rdi
callq 0x61d0
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x943e
leaq 0x230e3(%rip), %rsi     # 0x3bfa7
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x941a
leaq 0x21689(%rip), %rdx     # 0x3a563
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x93fb
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x48(%rsp), %rdi
callq 0x61d0
leaq 0x28(%rsp), %rdi
callq 0x61d0
leaq 0x8(%rsp), %rdi
callq 0x61d0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x18f25
jmp 0x18f34
jmp 0x18f43
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x61d0
jmp 0x18f37
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x61d0
jmp 0x18f46
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x61d0
jmp 0x18f57
jmp 0x18f54
movq %rax, %r14
movq %rbx, %rdi
callq 0x61d0
movq %r14, %rdi
callq 0x6650
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19705
movq %rax, 0x70(%rsi)
leaq 0x68(%rsi), %rdi
movq 0x80(%rsi), %rax
cmpq %rax, 0x88(%rsi)
je 0x19720
movq %rax, 0x88(%rsi)
addq $0xf0, %rsi
jmp 0x16f90
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14d
movslq %edx, %rax
movq 0x18(%rsi), %rcx
subq 0x10(%rsi), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
jb 0x19825
movq %rsi, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, 0x8(%rsp)
andq $0x0, 0x10(%rdi)
movq 0x70(%rsi), %rsi
subq 0x68(%r15), %rsi
sarq $0x3, %rsi
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x17216
movq 0x68(%r15), %rsi
movq 0x70(%r15), %rdx
subq %rsi, %rdx
je 0x1979a
movq 0x10(%rsp), %rdi
callq 0x65c0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x60(%r15), %rdx
callq 0x17270
xorl %ebx, %ebx
testl %r14d, %r14d
cmovlel %ebx, %r14d
leaq 0x30(%rsp), %r15
leaq 0x28(%rsp), %r12
pushq $0x1
popq %r13
leaq 0x7(%rsp), %rbp
cmpq %rbx, %r14
je 0x19807
movq 0x10(%rsp), %rax
movq (%rax,%rbx,8), %rax
movq %rax, 0x28(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x927a
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x15146
movq %r15, %rdi
callq 0x990e
incq %rbx
jmp 0x197c9
leaq 0x10(%rsp), %rdi
callq 0x990e
movq 0x8(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x4076c(%rip), %rdi     # 0x59f98
leaq 0x2287f(%rip), %rsi     # 0x3c0b2
callq 0x63a0
movq %rax, %rdi
movl %r14d, %esi
callq 0x6630
leaq 0x20d19(%rip), %rsi     # 0x3a563
movq %rax, %rdi
callq 0x63a0
pushq $0x1
popq %rdi
callq 0x6450
jmp 0x19861
movq %rax, %r14
jmp 0x1987d
movq %rax, %r14
jmp 0x19873
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x990e
leaq 0x10(%rsp), %rdi
callq 0x990e
movq 0x8(%rsp), %rdi
callq 0x92ec
movq %r14, %rdi
callq 0x6650
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/graph/pd.cpp
// Function: PD::logStr[abi:cxx11]()
std::string PD::logStr() {
  std::string str = SimpleGrid::logStr();
  str += "[graph] pickup:";
  for (auto v : pickup) str += std::to_string(v->getId()) + ",";
  str += "\n[graph] delivery:";
  for (auto v : delivery) str += std::to_string(v->getId()) + ",";
  str += "\n[graph] endpoints:";
  for (auto v : endpoints) str += std::to_string(v->getId()) + ",";
  str += "\n";
  return str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1ac04
leaq 0x22555(%rip), %rsi     # 0x3c0db
movq %rbx, %rdi
callq 0x66a0
movq 0xc0(%r14), %rbp
movq %r14, (%rsp)
movq 0xc8(%r14), %r14
leaq 0x8(%rsp), %r15
leaq 0x21924(%rip), %r12     # 0x3b4d0
leaq 0x28(%rsp), %r13
cmpq %r14, %rbp
je 0x19bf3
movq (%rbp), %rax
movl (%rax), %esi
movq %r15, %rdi
callq 0x943e
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x93fb
movq %rbx, %rdi
movq %r13, %rsi
callq 0x66c0
movq %r13, %rdi
callq 0x61d0
movq %r15, %rdi
callq 0x61d0
addq $0x8, %rbp
jmp 0x19bb1
leaq 0x224f1(%rip), %rsi     # 0x3c0eb
movq %rbx, %rdi
callq 0x66a0
movq (%rsp), %rax
movq 0xd8(%rax), %rbp
movq 0xe0(%rax), %r14
leaq 0x8(%rsp), %r15
leaq 0x218b0(%rip), %r12     # 0x3b4d0
leaq 0x28(%rsp), %r13
cmpq %r14, %rbp
je 0x19c67
movq (%rbp), %rax
movl (%rax), %esi
movq %r15, %rdi
callq 0x943e
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x93fb
movq %rbx, %rdi
movq %r13, %rsi
callq 0x66c0
movq %r13, %rdi
callq 0x61d0
movq %r15, %rdi
callq 0x61d0
addq $0x8, %rbp
jmp 0x19c25
leaq 0x22490(%rip), %rsi     # 0x3c0fe
movq %rbx, %rdi
callq 0x66a0
movq (%rsp), %rax
movq 0xf0(%rax), %r13
movq 0xf8(%rax), %rbp
leaq 0x8(%rsp), %r14
leaq 0x2183c(%rip), %r15     # 0x3b4d0
leaq 0x28(%rsp), %r12
cmpq %rbp, %r13
je 0x19cdb
movq (%r13), %rax
movl (%rax), %esi
movq %r14, %rdi
callq 0x943e
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x93fb
movq %rbx, %rdi
movq %r12, %rsi
callq 0x66c0
movq %r12, %rdi
callq 0x61d0
movq %r14, %rdi
callq 0x61d0
addq $0x8, %r13
jmp 0x19c99
leaq 0x20881(%rip), %rsi     # 0x3a563
movq %rbx, %rdi
callq 0x66a0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x19d0a
jmp 0x19d0a
jmp 0x19d0f
jmp 0x19d14
jmp 0x19d0a
jmp 0x19d0f
jmp 0x19d14
movq %rax, %r14
jmp 0x19d2b
movq %rax, %r14
jmp 0x19d21
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x61d0
leaq 0x8(%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/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 0x19e94
movq %rbx, %rdi
callq 0x1a1a4
movq %rbx, %rdi
callq 0x1a4e0
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x68(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, 0x8(%rsp)
movl %eax, 0xc(%rsp)
movq %r15, %rdi
callq 0x1ada0
cltq
movq 0x80(%r14), %rcx
movq (%rcx,%rax,8), %rax
cmpq %rbx, %rax
je 0x1abc3
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
pushq $-0x1
popq %rbp
xorl %eax, %eax
leaq 0x8(%rsp), %r13
movl %eax, 0x4(%rsp)
movslq %eax, %rcx
movq 0xd0(%rbx), %rax
subq 0xc8(%rbx), %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cmpq %rcx, %rax
jbe 0x1bb96
leaq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rsi
callq 0x1be2c
movslq 0x4(%rsp), %rax
movq 0xc8(%rbx), %r12
imulq $0x18, %rax, %r15
movq %r14, 0x8(%rsp)
movq (%r12,%r15), %rdi
movq 0x8(%r12,%r15), %rsi
movq %r13, %rdx
callq 0x15de1
addq %r15, %r12
cmpq 0x8(%r12), %rax
movl 0x4(%rsp), %eax
cmovnel %eax, %ebp
incl %eax
jmp 0x1bb2c
leaq 0x10(%rsp), %r14
movq 0x60(%rbx), %rsi
movq %r14, %rdi
callq 0x1baca
cmpl %ebp, %eax
je 0x1bb9b
cltq
movq 0xc8(%rbx), %r14
imulq $0x18, %rax, %r15
movq 0x8(%r14,%r15), %rax
subq (%r14,%r15), %rax
movq 0x60(%rbx), %rsi
shrq $0x3, %rax
decl %eax
leaq 0x8(%rsp), %rdi
andl $0x0, (%rdi)
movl %eax, 0x4(%rdi)
callq 0x1ada0
addq %r15, %r14
cltq
movq (%r14), %rcx
movq (%rcx,%rax,8), %rbx
leaq 0x10(%rsp), %rdi
callq 0x1c0a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1bc07
jmp 0x1bc07
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1c0a0
movq %rbx, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/graph/station.cpp
// Function: Station::logStr[abi:cxx11]()
std::string Station::logStr() {
  std::string str = SimpleGrid::logStr();
  for (int i = 0; i < stations.size(); ++i) {
    str += "[graph] St." + std::to_string(i) + ":";
    for (auto v : stations[i]) str += std::to_string(v->getId()) + ",";
    str += "\n";
  }
  return str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1ac04
xorl %r15d, %r15d
leaq 0x38(%rsp), %rbp
leaq 0x58(%rsp), %r13
leaq 0x1f887(%rip), %r12     # 0x3b4d0
movq %r14, 0x8(%rsp)
movq 0xd0(%r14), %rax
subq 0xc8(%r14), %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cmpq %r15, %rax
jbe 0x1bd46
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movl %r15d, %esi
callq 0x943e
movq %rbp, %rdi
leaq 0x2061c(%rip), %rsi     # 0x3c2a3
movq %r14, %rdx
callq 0x941a
movq %r13, %rdi
movq %rbp, %rsi
leaq 0x20843(%rip), %rdx     # 0x3c4df
callq 0x93fb
movq %rbx, %rdi
movq %r13, %rsi
callq 0x66c0
movq %r13, %rdi
callq 0x61d0
movq %rbp, %rdi
callq 0x61d0
leaq 0x18(%rsp), %rdi
callq 0x61d0
movq 0x8(%rsp), %rax
movq 0xc8(%rax), %rax
movq %r15, 0x10(%rsp)
imulq $0x18, %r15, %rcx
movq (%rax,%rcx), %r14
movq 0x8(%rax,%rcx), %r15
cmpq %r15, %r14
je 0x1bd25
movq (%r14), %rax
movl (%rax), %esi
movq %rbp, %rdi
callq 0x943e
movq %r13, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x93fb
movq %rbx, %rdi
movq %r13, %rsi
callq 0x66c0
movq %r13, %rdi
callq 0x61d0
movq %rbp, %rdi
callq 0x61d0
addq $0x8, %r14
jmp 0x1bce4
movq %rbx, %rdi
leaq 0x1e834(%rip), %rsi     # 0x3a563
callq 0x66a0
movq 0x10(%rsp), %r15
incq %r15
movq 0x8(%rsp), %r14
jmp 0x1bc4e
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1bd84
jmp 0x1bd84
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x61d0
jmp 0x1bd6e
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x61d0
jmp 0x1bd7d
movq %rax, %r14
leaq 0x18(%rsp), %rdi
jmp 0x1bda0
movq %rax, %r14
jmp 0x1bda5
movq %rax, %r14
jmp 0x1bd9b
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x61d0
leaq 0x38(%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/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
andl $0x0, 0x90(%rdi)
addq $0xb0, %rdi
leaq 0x1fd25(%rip), %rsi     # 0x3c2b8
callq 0x66b0
movq 0x10(%rbx), %rsi
addq $0x10, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x15d3a
leaq 0x98(%rbx), %rdi
movq %r14, %rsi
callq 0x18466
movq %r14, %rdi
callq 0x990e
movq 0x18(%rbx), %r15
movq 0x20(%rbx), %r12
cmpq %r12, %r15
je 0x1c5eb
movq (%r15), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c716
movq %r14, %rdi
callq 0x159d0
addq $0x8, %r15
jmp 0x1c5ca
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x8(%rsi), %rsi
movq (%rdi), %rax
callq *0x30(%rax)
movq %rax, %r12
pushq $0x40
popq %rdi
callq 0x63b0
movq %rax, %r15
movl 0x8(%rbx), %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x39218
movq %rsp, %r12
movq %r15, (%r12)
movq %r15, 0x18(%r14)
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x15d3a
movq (%r13), %rax
movq (%rax), %rax
movq %rax, 0x10(%r14)
movq %r13, %rdi
callq 0x990e
addq $0x30, %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x932c
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x40
popq %rsi
movq %r15, %rdi
callq 0x63c0
movq %rbx, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %eax, %eax
cmpl %ecx, 0x90(%rdi)
jl 0x1c89b
pushq %r14
pushq %rbx
movq 0x48(%rdi), %rdx
movq 0x50(%rdi), %rsi
movq %rsi, %rdi
subq %rdx, %rdi
movq %rdi, %r8
sarq $0x5, %r8
testl %ecx, %ecx
movl $0x0, %r9d
cmovgl %ecx, %r9d
cmpl %r9d, %eax
je 0x1c893
movq %rdi, %r11
movq %rdx, %r10
movq %r8, %rbx
testq %rbx, %rbx
jle 0x1c837
movq (%r10), %r14
cmpl %eax, 0x30(%r14)
je 0x1c884
movq 0x8(%r10), %r14
cmpl %eax, 0x30(%r14)
je 0x1c874
movq 0x10(%r10), %r14
cmpl %eax, 0x30(%r14)
je 0x1c87a
movq 0x18(%r10), %r14
cmpl %eax, 0x30(%r14)
je 0x1c880
addq $0x20, %r10
decq %rbx
addq $-0x20, %r11
jmp 0x1c7fe
sarq $0x3, %r11
cmpq $0x1, %r11
je 0x1c867
cmpq $0x2, %r11
je 0x1c85a
cmpq $0x3, %r11
jne 0x1c88f
movq (%r10), %r11
cmpl %eax, 0x30(%r11)
je 0x1c884
addq $0x8, %r10
movq (%r10), %r11
cmpl %eax, 0x30(%r11)
je 0x1c884
addq $0x8, %r10
movq (%r10), %r11
cmpl %eax, 0x30(%r11)
cmovneq %rsi, %r10
jmp 0x1c884
addq $0x8, %r10
jmp 0x1c884
addq $0x10, %r10
jmp 0x1c884
addq $0x18, %r10
incl %eax
cmpq %rsi, %r10
jne 0x1c7ec
xorl %eax, %eax
jmp 0x1c898
cmpl %ecx, %eax
setge %al
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/problem/imapf.cpp
// Function: IMAPF::update()
void IMAPF::update() {
  ++timestep;

  for (auto a : A) {
    auto tau = a->getTask();
    if (tau) {
      tau->update(a->getNode());

      if (tau->completed()) {
        ++taskSum;
        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();
  }

  taskSumStr += std::to_string(taskSum) + ",";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
incl 0x8(%rdi)
movq 0x18(%rdi), %r12
movq 0x20(%rdi), %r14
leaq 0x30(%rdi), %rax
movq %rax, (%rsp)
leaq 0x48(%rdi), %r15
cmpq %r14, %r12
je 0x1c977
movq (%r12), %r13
movq 0x18(%r13), %rbp
testq %rbp, %rbp
je 0x1c954
movq 0x8(%r13), %rsi
movq %rbp, %rdi
callq 0x39324
movq %rbp, %rdi
callq 0x39366
testb %al, %al
je 0x1c961
incl 0x90(%rbx)
movl 0x8(%rbx), %esi
movq %rbp, %rdi
callq 0x39372
movq %r13, %rdi
callq 0x15a0a
movq %rbp, 0x8(%rsp)
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
leaq 0x8(%rsp), %rdx
callq 0x1cd5d
cmpq 0x38(%rbx), %rax
je 0x1c942
movq %rax, %rbp
movq %r15, %rdi
movq %rax, %rsi
callq 0x932c
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0x1cd24
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1c716
movb $0x1, 0x38(%r13)
jmp 0x1c966
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1c716
jmp 0x1c966
movb $0x0, 0x38(%r13)
movq %r13, %rdi
callq 0x159d0
addq $0x8, %r12
jmp 0x1c8c4
movl 0x90(%rbx), %esi
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x943e
leaq 0x1eb3f(%rip), %rdx     # 0x3b4d0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x93fb
addq $0xb0, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
leaq 0x28(%rsp), %rdi
callq 0x61d0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x61d0
jmp 0x1c9e7
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x61d0
movq %rbx, %rdi
callq 0x6650
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/problem/imapf.cpp
// Function: IMAPF::logStr[abi:cxx11]()
std::string IMAPF::logStr() {
  std::string str = Problem::logStr();
  str += "[problem] type:IMAPF\n";
  str += "[problem] agentnum:" + std::to_string(A.size()) + "\n";
  str += "[problem] tasknum:" + std::to_string(taskLimit) + "\n";
  str += "[problem] tasksum:" + taskSumStr + "\n";
  str += G->logStr();
  for (auto tau : T_CLOSE) str += tau->logStr();
  for (auto a : A) str += a->logStr();
  return str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1edcc
leaq 0x1f8a2(%rip), %rsi     # 0x3c2bb
movq %rbx, %rdi
callq 0x66a0
movq 0x20(%r14), %rsi
subq 0x18(%r14), %rsi
sarq $0x3, %rsi
leaq 0x40(%rsp), %rdi
callq 0x1cc40
leaq 0x1f893(%rip), %rsi     # 0x3c2d1
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x941a
leaq 0x1db0f(%rip), %rdx     # 0x3a563
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x93fb
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x66c0
movq %rsp, %rdi
callq 0x61d0
leaq 0x20(%rsp), %rdi
callq 0x61d0
leaq 0x40(%rsp), %rdi
callq 0x61d0
movl 0x94(%r14), %esi
leaq 0x40(%rsp), %rdi
callq 0x943e
leaq 0x1f845(%rip), %rsi     # 0x3c2e5
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x941a
leaq 0x1daad(%rip), %rdx     # 0x3a563
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x93fb
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x66c0
movq %rsp, %rdi
callq 0x61d0
leaq 0x20(%rsp), %rdi
callq 0x61d0
leaq 0x40(%rsp), %rdi
callq 0x61d0
leaq 0xb0(%r14), %rdx
leaq 0x1f800(%rip), %rsi     # 0x3c2f8
leaq 0x20(%rsp), %rdi
callq 0x9497
leaq 0x1da5a(%rip), %rdx     # 0x3a563
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x93fb
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x66c0
movq %rsp, %rdi
callq 0x61d0
leaq 0x20(%rsp), %rdi
callq 0x61d0
movq 0x10(%r14), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x60(%rax)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x66c0
movq %rsp, %r15
movq %r15, %rdi
callq 0x61d0
movq 0x48(%r14), %r12
movq 0x50(%r14), %r13
cmpq %r13, %r12
je 0x1cb88
movq (%r12), %rsi
movq %r15, %rdi
callq 0x3937a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x66c0
movq %r15, %rdi
callq 0x61d0
addq $0x8, %r12
jmp 0x1cb5e
movq 0x18(%r14), %r15
movq 0x20(%r14), %r12
movq %rsp, %r14
cmpq %r12, %r15
je 0x1cbbc
movq (%r15), %rsi
movq %r14, %rdi
callq 0x15a1e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x66c0
movq %r14, %rdi
callq 0x61d0
addq $0x8, %r15
jmp 0x1cb93
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1cc25
jmp 0x1cc20
movq %rax, %r14
movq %rsp, %rdi
callq 0x61d0
jmp 0x1cbe1
movq %rax, %r14
leaq 0x20(%rsp), %rdi
jmp 0x1cc2b
jmp 0x1cc20
jmp 0x1cbf2
jmp 0x1cbff
jmp 0x1cc0e
jmp 0x1cc20
movq %rax, %r14
movq %rsp, %rdi
callq 0x61d0
jmp 0x1cc02
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x61d0
jmp 0x1cc11
movq %rax, %r14
leaq 0x40(%rsp), %rdi
jmp 0x1cc2b
jmp 0x1cc20
jmp 0x1cc20
jmp 0x1cc20
jmp 0x1cc25
movq %rax, %r14
jmp 0x1cc30
movq %rax, %r14
movq %rsp, %rdi
callq 0x61d0
movq %rbx, %rdi
callq 0x61d0
movq %r14, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
andl $0x0, 0x94(%rdi)
movq 0x18(%rdi), %r13
movq 0x20(%rdi), %rbp
leaq 0x98(%rdi), %r14
leaq 0x4(%rsp), %r15
cmpq %rbp, %r13
je 0x1cee1
movq (%r13), %r12
andl $0x0, 0x4(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1d402
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1cfd6
movq %r12, %rdi
callq 0x159d0
addq $0x8, %r13
jmp 0x1ceaf
addq $0x8, %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/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
incl 0x8(%rdi)
leaq 0x30(%rdi), %r14
leaq 0x48(%rdi), %r15
xorl %r12d, %r12d
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jbe 0x1d15c
movq (%rax,%r12,8), %r13
movq 0x18(%r13), %rbp
testq %rbp, %rbp
je 0x1d13a
movq 0x8(%r13), %rsi
movq %rbp, %rdi
callq 0x39324
movq %rbp, %rdi
callq 0x39366
testb %al, %al
je 0x1d147
incl 0x94(%rbx)
movq 0x98(%rbx), %rax
incl (%rax,%r12,4)
movl 0x8(%rbx), %esi
movq %rbp, %rdi
callq 0x39372
movq %r13, %rdi
callq 0x15a0a
movq %rbp, (%rsp)
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
movq %rsp, %rdx
callq 0x1cd5d
cmpq 0x38(%rbx), %rax
je 0x1d128
movq %rax, %rbp
movq %r15, %rdi
movq %rax, %rsi
callq 0x932c
movq %r14, %rdi
movq %rbp, %rsi
callq 0x1cd24
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1cfd6
movb $0x1, 0x38(%r13)
jmp 0x1d14c
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1cfd6
jmp 0x1d14c
movb $0x0, 0x38(%r13)
movq %r13, %rdi
callq 0x159d0
incq %r12
jmp 0x1d090
addq $0x8, %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/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), %rcx
subq 0x18(%rdi), %rcx
movslq 0x90(%rdi), %rdx
sarq $0x3, %rcx
imulq %rdx, %rcx
cmpq %rax, %rcx
jbe 0x1d192
xorl %eax, %eax
retq
movq 0x98(%rdi), %rcx
movq 0xa0(%rdi), %rax
movq %rax, %rsi
subq %rcx, %rsi
movq %rsi, %rdi
sarq $0x4, %rdi
testq %rdi, %rdi
jle 0x1d1d2
cmpl (%rcx), %edx
jg 0x1d213
cmpl 0x4(%rcx), %edx
jg 0x1d203
cmpl 0x8(%rcx), %edx
jg 0x1d209
cmpl 0xc(%rcx), %edx
jg 0x1d20f
addq $0x10, %rcx
decq %rdi
addq $-0x10, %rsi
jmp 0x1d1ad
sarq $0x2, %rsi
cmpq $0x1, %rsi
je 0x1d1fb
cmpq $0x2, %rsi
je 0x1d1f3
movq %rax, %rdi
cmpq $0x3, %rsi
jne 0x1d216
cmpl (%rcx), %edx
jg 0x1d213
addq $0x4, %rcx
cmpl (%rcx), %edx
jg 0x1d213
addq $0x4, %rcx
cmpl (%rcx), %edx
cmovleq %rax, %rcx
jmp 0x1d213
addq $0x4, %rcx
jmp 0x1d213
addq $0x8, %rcx
jmp 0x1d213
addq $0xc, %rcx
movq %rcx, %rdi
cmpq %rax, %rdi
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/problem/imapf_fair.cpp
// Function: IMAPF_FAIR::logStr[abi:cxx11]()
std::string IMAPF_FAIR::logStr() {
  std::string str = Problem::logStr();
  str += "[problem] type:IMAPF_FAIR\n";
  str += "[problem] agentnum:" + std::to_string(A.size()) + "\n";
  str += "[problem] tasknum:" + std::to_string(taskLimit) + "\n";
  str += G->logStr();
  for (auto tau : T_CLOSE) str += tau->logStr();
  for (auto a : A) str += a->logStr();
  return str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1edcc
leaq 0x1f1ac(%rip), %rsi     # 0x3c3e9
movq %rbx, %rdi
callq 0x66a0
movq 0x20(%r14), %rsi
subq 0x18(%r14), %rsi
sarq $0x3, %rsi
leaq 0x20(%rsp), %rdi
callq 0x1cc40
leaq 0x1f06f(%rip), %rsi     # 0x3c2d1
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x941a
leaq 0x1d2eb(%rip), %rdx     # 0x3a563
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x93fb
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x66c0
movq %rsp, %rdi
callq 0x61d0
leaq 0x40(%rsp), %rdi
callq 0x61d0
leaq 0x20(%rsp), %rdi
callq 0x61d0
movl 0x90(%r14), %esi
leaq 0x20(%rsp), %rdi
callq 0x943e
leaq 0x1f021(%rip), %rsi     # 0x3c2e5
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x941a
leaq 0x1d289(%rip), %rdx     # 0x3a563
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x93fb
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x66c0
movq %rsp, %rdi
callq 0x61d0
leaq 0x40(%rsp), %rdi
callq 0x61d0
leaq 0x20(%rsp), %rdi
callq 0x61d0
movq 0x10(%r14), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x60(%rax)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x66c0
movq %rsp, %r15
movq %r15, %rdi
callq 0x61d0
movq 0x48(%r14), %r12
movq 0x50(%r14), %r13
cmpq %r13, %r12
je 0x1d363
movq (%r12), %rsi
movq %r15, %rdi
callq 0x3937a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x66c0
movq %r15, %rdi
callq 0x61d0
addq $0x8, %r12
jmp 0x1d339
movq 0x18(%r14), %r15
movq 0x20(%r14), %r12
movq %rsp, %r14
cmpq %r12, %r15
je 0x1d397
movq (%r15), %rsi
movq %r14, %rdi
callq 0x15a1e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x66c0
movq %r14, %rdi
callq 0x61d0
addq $0x8, %r15
jmp 0x1d36e
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1d3e7
jmp 0x1d3e2
jmp 0x1d3b4
jmp 0x1d3c1
jmp 0x1d3d0
jmp 0x1d3e2
movq %rax, %r14
movq %rsp, %rdi
callq 0x61d0
jmp 0x1d3c4
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x61d0
jmp 0x1d3d3
movq %rax, %r14
leaq 0x20(%rsp), %rdi
jmp 0x1d3ed
jmp 0x1d3e2
jmp 0x1d3e2
jmp 0x1d3e2
jmp 0x1d3e7
movq %rax, %r14
jmp 0x1d3f2
movq %rax, %r14
movq %rsp, %rdi
callq 0x61d0
movq %rbx, %rdi
callq 0x61d0
movq %r14, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/problem/mapd.cpp
// Function: MAPD::init()
void MAPD::init() {
  taskCnt = 0;
  autoAssignment = true;
  --timestep;
  update();
}

// Assembly:
andl $0x0, 0xc0(%rdi)
movb $0x1, 0xcc(%rdi)
decl 0x8(%rdi)
movq (%rdi), %rax
jmpq *0x18(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1da93
movq 0x30(%rdi), %rax
cmpq 0x38(%rdi), %rax
jne 0x1da93
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
movq %rsi, %rax
sarq $0x5, %rax
testq %rax, %rax
jle 0x1da3c
movq (%rcx), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x1da8e
movq 0x8(%rcx), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x1da7e
movq 0x10(%rcx), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x1da84
movq 0x18(%rcx), %rdi
cmpq $0x0, 0x18(%rdi)
jne 0x1da8a
addq $0x20, %rcx
decq %rax
addq $-0x20, %rsi
jmp 0x1d9fb
sarq $0x3, %rsi
cmpq $0x1, %rsi
je 0x1da70
cmpq $0x2, %rsi
je 0x1da62
movb $0x1, %al
cmpq $0x3, %rsi
jne 0x1da95
movq (%rcx), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1da8e
addq $0x8, %rcx
movq (%rcx), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1da8e
addq $0x8, %rcx
movq (%rcx), %rax
cmpq $0x0, 0x18(%rax)
cmoveq %rdx, %rcx
jmp 0x1da8e
addq $0x8, %rcx
jmp 0x1da8e
addq $0x10, %rcx
jmp 0x1da8e
addq $0x18, %rcx
cmpq %rdx, %rcx
je 0x1da96
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1dae6
movq %rbx, %rdi
callq 0x1db92
cmpb $0x1, 0xcc(%rbx)
jne 0x1dac2
movq %rbx, %rdi
callq 0x1dcc4
movq 0x18(%rbx), %r14
movq 0x20(%rbx), %rbx
cmpq %rbx, %r14
je 0x1dadd
movq (%r14), %rdi
callq 0x159d0
addq $0x8, %r14
jmp 0x1daca
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1dc9f
movq %rdi, %rbx
movss 0xc8(%rdi), %xmm0
ucomiss 0x1e850(%rip), %xmm0    # 0x3c414
jae 0x1dbe5
movss 0x1e846(%rip), %xmm1    # 0x3c414
divss %xmm0, %xmm1
cvttss2si %xmm1, %esi
movl 0x8(%rbx), %eax
cltd
idivl %esi
xorl %eax, %eax
testl %edx, %edx
sete %al
jmp 0x1dbe9
cvttss2si %xmm0, %eax
leaq 0x90(%rbx), %r14
leaq 0xa8(%rbx), %r15
leaq 0x30(%rbx), %rdx
movq %rdx, 0x10(%rsp)
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
movl %eax, (%rsp)
cmpl %eax, %edx
je 0x1dc9f
cmpl 0xc4(%rbx), %ecx
jge 0x1dc98
movl %edx, 0x4(%rsp)
movq 0x60(%rbx), %rsi
movq %r14, %rdi
callq 0x1de14
movq %rax, %r13
movq 0x60(%rbx), %rsi
movq %r15, %rdi
callq 0x1de14
cmpq %rax, %r13
je 0x1dc1e
movq %rax, %rbp
pushq $0x40
popq %rdi
callq 0x63b0
movq %rax, %r12
movl 0x8(%rbx), %esi
movq %rax, %rdi
callq 0x391f0
movq %r12, 0x8(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x1e0fc
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x1e0fc
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x932c
movl 0xc0(%rbx), %ecx
incl %ecx
movl %ecx, 0xc0(%rbx)
movl (%rsp), %eax
movl 0x4(%rsp), %edx
incl %edx
jmp 0x1dc0a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x40
popq %rsi
movq %r12, %rdi
callq 0x63c0
movq %rbx, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
incl 0x8(%rdi)
movq 0x18(%rdi), %r15
movq 0x20(%rdi), %r13
leaq 0x30(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rdi), %rax
movq %rax, 0x10(%rsp)
cmpq %r13, %r15
je 0x1e5fd
movq (%r15), %r12
movq 0x8(%r12), %rsi
movq 0x18(%r12), %rbp
testq %rbp, %rbp
je 0x1e58f
movq %rbp, %rdi
callq 0x39324
movq %rbp, %rdi
callq 0x39366
testb %al, %al
je 0x1e5ec
movq %r12, %rdi
callq 0x15a12
movq %rbp, 0x20(%rsp)
movq 0x30(%rbx), %rdi
movq 0x38(%rbx), %rsi
leaq 0x20(%rsp), %rdx
callq 0x1cd5d
cmpq 0x38(%rbx), %rax
je 0x1e5ec
movq %rax, %rbp
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x932c
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x1cd24
jmp 0x1e5ec
cmpq 0x10(%r12), %rsi
je 0x1e5ec
pushq $0x40
popq %rdi
callq 0x63b0
movq %rax, %rbp
movq 0x10(%r12), %rsi
movq %rax, %rdi
callq 0x39192
movq %rbp, 0x18(%rsp)
movq %rbp, 0x18(%r12)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
callq 0x15d3a
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%r12)
movq %r14, %rdi
callq 0x990e
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x932c
movq %r12, %rdi
callq 0x159d0
addq $0x8, %r15
jmp 0x1e518
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x40
popq %rsi
movq %rbp, %rdi
callq 0x63c0
movq %rbx, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x3ad90(%rip), %rax     # 0x599f0
movq %rax, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rdi), %rbx
movq 0x20(%rdi), %r13
pushq $0x48
popq %r15
cmpq %r13, %rbx
je 0x1ec9e
movq (%rbx), %r12
testq %r12, %r12
je 0x1ec8d
movq %r12, %rdi
callq 0x1597e
movq %r12, %rdi
movq %r15, %rsi
callq 0x63c0
addq $0x8, %rbx
jmp 0x1ec78
leaq 0x30(%r14), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%r14), %rbp
movq 0x38(%r14), %rbx
pushq $0x40
popq %r12
cmpq %rbx, %rbp
je 0x1ecda
movq (%rbp), %r13
testq %r13, %r13
je 0x1ecc9
movq %r13, %rdi
callq 0x392f2
movq %r13, %rdi
movq %r12, %rsi
callq 0x63c0
addq $0x8, %rbp
jmp 0x1ecb3
leaq 0x48(%r14), %r12
movq 0x48(%r14), %rbx
movq 0x50(%r14), %r15
pushq $0x40
popq %r13
cmpq %r15, %rbx
je 0x1ed10
movq (%rbx), %rbp
testq %rbp, %rbp
je 0x1ecff
movq %rbp, %rdi
callq 0x392f2
movq %rbp, %rdi
movq %r13, %rsi
callq 0x63c0
addq $0x8, %rbx
jmp 0x1ecea
movq 0x18(%r14), %rax
cmpq %rax, 0x20(%r14)
je 0x1ed1e
movq %rax, 0x20(%r14)
movq 0x30(%r14), %rax
cmpq %rax, 0x38(%r14)
je 0x1ed2c
movq %rax, 0x38(%r14)
addq $0x70, %r14
movq %r14, %rdi
callq 0x61d0
movq %r12, %rdi
callq 0x154b6
movq 0x8(%rsp), %rdi
callq 0x154b6
movq 0x10(%rsp), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x15420