LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::PUSH(S*)
RES PPS::PUSH(S* s) {
  Agent* aH = s->agents[0];
  Agent* aL = s->agents[1];
  Node* target = s->esv[0];

  if (inArray(aH, M)) return RES::PAUSE;
  if (inArray(aL, M)) return RES::PAUSE;

  // check which is the nearest
  if (s->agents.size() == 2) {
    if (pathDist(aH->getNode(), target) > pathDist(aL->getNode(), target)) {
      s->agents = { aL, aH };
      aH = s->agents[0];
      aL = s->agents[1];
    }
  }

  if (aH->getNode() == target) {
    return SWAP(s);
  }

  Nodes pi = SHORTEST_PATH(aH->getNode(), target);  // l.6

  RES attempt = FEASIBLE(s, pi);  // l.16

  if (attempt == RES::SUCCESS) {  // l.17
    move(s, pi);  // l.18
    for (auto a : s->agents) M.push_back(a);  // l.18
  }

  return attempt;  // l.19
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rsi), %rax
movq 0x28(%rsi), %rcx
movq (%rax), %r13
movq 0x8(%rax), %r12
movq (%rcx), %rax
movq %rax, 0x10(%rsp)
leaq 0xe0(%rdi), %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2ea4f
pushq $0x2
popq %rbp
testb %al, %al
jne 0x2f90d
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2ea4f
testb %al, %al
jne 0x2f90d
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
cmpq $0x10, %rax
jne 0x2f8c0
movq 0x8(%r13), %rsi
movq %r15, %rdi
movq 0x10(%rsp), %rbp
movq %rbp, %rdx
callq 0x32cd4
movl %eax, 0xc(%rsp)
movq 0x8(%r12), %rsi
movq %r15, %rdi
movq %rbp, %rdx
callq 0x32cd4
cmpl %eax, 0xc(%rsp)
jle 0x2f8c0
leaq 0x8(%r14), %rbp
leaq 0x30(%rsp), %rdx
movq %r12, -0x10(%rdx)
movq %r13, -0x8(%rdx)
leaq 0x20(%rsp), %rsi
movq %rbp, %rdi
callq 0x31c34
movq (%rbp), %rax
movq (%rax), %r13
movq 0x8(%r13), %rdx
movq 0x10(%rsp), %rcx
cmpq %rcx, %rdx
je 0x2f900
movq 0x38(%r15), %rsi
movq (%rsi), %rax
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq *0x18(%rax)
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2f982
movl %eax, %ebp
testl %eax, %eax
je 0x2f91e
leaq 0x20(%rsp), %rdi
callq 0x990e
jmp 0x2f90d
movq %r15, %rdi
movq %r14, %rsi
callq 0x2e74e
movl %eax, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20(%rsp), %rdx
movq %r14, %rsi
callq 0x2fb0a
movq 0x8(%r14), %r15
movq 0x10(%r14), %r12
leaq 0x18(%rsp), %r14
cmpq %r12, %r15
je 0x2f8f4
movq (%r15), %rax
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x930e
addq $0x8, %r15
jmp 0x2f938
jmp 0x2f958
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x990e
movq %rbx, %rdi
callq 0x6650
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::move(S*, std::vector<Node*, std::allocator<Node*>>&)
void PPS::move(S* s, Nodes &pi) {
  // error check
  if (s->phase != SWAPPHASE::GO_TARGET &&
      s->phase != SWAPPHASE::CLEARING) {
    std::cout << "error@PPS::move, invalid movement" << "\n";
    std::exit(1);
  }

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, 0x78(%rsi)
jae 0x2fb47
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rax
movq (%rax), %rdi
movq (%rdx), %rax
movq 0x8(%rax), %rsi
callq 0x158b4
movq 0x8(%r14), %rax
movq 0x8(%rax), %rdi
movq (%rbx), %rax
movq (%rax), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x158b4
movq 0x2a44a(%rip), %rdi     # 0x59f98
leaq 0xdbde(%rip), %rsi      # 0x3d733
callq 0x63a0
leaq 0xaa02(%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/solver/pps.cpp
// Function: PPS::DEPEND(std::vector<Node*, std::allocator<Node*>>, std::vector<Node*, std::allocator<Node*>>)
bool PPS::DEPEND(Nodes piA, Nodes piB) {
  // cond (a)
  if (inArray(piB[0], piA) && inArray(piB[piB.size()-1], piA)) return true;
  // cond (b)
  if (inArray(piB[0], piA) && inArray(piA[0], piB)) return true;

  return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdx), %rax
movq (%rax), %rdi
callq 0x2fc19
testb %al, %al
je 0x2fc73
movq 0x8(%rbx), %rax
movq -0x8(%rax), %rdi
movq %r14, %rsi
callq 0x2fc19
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x2fc9d
movq (%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0x2fc19
testb %al, %al
je 0x2fc9b
movq (%r14), %rax
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x2fc19
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x2fc9d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::SETUP_SWAP(Agent*, Agent*)
void PPS::SETUP_SWAP(Agent* c, Agent* a) {
  // error check
  if (deg3nodes.size() == 0) {
    std::cout << "error@PPS::SETUP_SWAP, graph does not have esv" << "\n";
    std::exit(1);
  }

  Nodes sorted_esv = getSortedEsv(c);  // l.14
  Node* v = sorted_esv[0];
  Agents agents;
  if (pathDist(c->getNode(), v) <= pathDist(a->getNode(), v)) {
    agents = {c, a};
  } else {
    agents = {a, c};
  }

  S* s = new S { s_uuid,
                 agents,  // [near (high), far (low)]
                 a->getNode(),  // [low] original pos
                 sorted_esv,
                 nullptr,  // target
                 nullptr,  // origin
                 nullptr,  // evacH
                 nullptr,  // evacL
                 {},       // area
                 SWAPPHASE::GO_TARGET };
  ++s_uuid;

  pusherToSwaper.push_back(c);
  pusherToSwaper.push_back(a);
  swapers.push_back(s);

  SWAP(s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x190(%rdi), %rax
cmpq 0x188(%rdi), %rax
je 0x2fe14
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x30ec4
movq (%r12), %rax
movq (%rax), %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq 0x8(%r15), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x32cd4
movl %eax, %ebp
movq 0x8(%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x32cd4
leaq 0x10(%rsp), %rdx
cmpl %eax, %ebp
jle 0x2fd41
movq %r14, -0x10(%rdx)
movq %r15, -0x8(%rdx)
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x31c34
jmp 0x2fd56
movq %r15, -0x10(%rdx)
movq %r14, -0x8(%rdx)
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x31c34
movl $0x80, %edi
callq 0x63b0
movq %rax, %r15
movl 0x2aa97(%rip), %eax     # 0x5a800
movl %eax, (%r15)
leaq 0x8(%r15), %r12
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0x934a
movq 0x8(%r14), %rax
movq %rax, 0x20(%r15)
movq %r15, %rdi
addq $0x28, %rdi
leaq 0x38(%rsp), %rsi
callq 0x15d3a
xorps %xmm0, %xmm0
movups %xmm0, 0x6c(%r15)
movaps %xmm0, 0x60(%r15)
movaps %xmm0, 0x50(%r15)
movaps %xmm0, 0x40(%r15)
movq %r15, (%rsp)
incl 0x2aa49(%rip)           # 0x5a800
leaq 0x98(%rbx), %r14
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x930e
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x930e
leaq 0x80(%rbx), %rdi
movq %rsp, %rsi
callq 0x31606
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x2e74e
leaq 0x10(%rsp), %rdi
callq 0x15420
leaq 0x38(%rsp), %rdi
callq 0x990e
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x2a17d(%rip), %rdi     # 0x59f98
leaq 0xd98c(%rip), %rsi      # 0x3d7ae
callq 0x63a0
leaq 0xa735(%rip), %rsi      # 0x3a563
movq %rax, %rdi
callq 0x63a0
pushq $0x1
popq %rdi
callq 0x6450
jmp 0x2fe63
jmp 0x2fe63
movq %rax, %rbx
movq %r12, %rdi
callq 0x15420
jmp 0x2fe52
movq %rax, %rbx
movl $0x80, %esi
movq %r15, %rdi
callq 0x63c0
jmp 0x2fe66
jmp 0x2fe63
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x15420
leaq 0x38(%rsp), %rdi
callq 0x990e
movq %rbx, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::ADD_DONE_SWAPERS(S*)
void PPS::ADD_DONE_SWAPERS(S* s) {
  doneSwapers.push_back(s);
  Agents agents = s->agents;
  if (agents.size() == 3) {
    Agent* a3 = agents[2];
    isTmpGoals[a3->getId()] = false;
    P->assign(a3->getTask());
    a3->releaseTask();
    a3->setGoal(goals[a3->getId()]);
  }
  for (auto a : agents) {
    if (!inArray(a, pushers)) {
      pushers.push_back(a);
    } else {
      std::cout << "error@PPS::ADD_DONE_SWAPERS, "
                << "duplicated pusher : " << a->getId()
                << "\n";
      std::exit(1);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, (%r14)
addq $0xc8, %rdi
movq %r14, %rsi
callq 0x31606
movq (%r14), %rsi
addq $0x8, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x934a
movq (%r14), %r15
movq 0x8(%r14), %r12
movq %r12, %rax
subq %r15, %rax
cmpq $0x18, %rax
jne 0x2ff7a
movq 0x10(%r15), %r14
leaq 0x160(%rbx), %rdi
movslq (%r14), %rsi
callq 0x315e8
notq %rdx
andq %rdx, (%rax)
movq 0x10(%rbx), %rdi
movq 0x18(%r14), %rsi
callq 0x1ed7a
movq %r14, %rdi
callq 0x15a0a
movslq (%r14), %rax
movq 0x148(%rbx), %rcx
movq (%rcx,%rax,8), %rax
movq %rax, 0x10(%r14)
movq 0x8(%rsp), %r15
movq 0x10(%rsp), %r12
addq $0x68, %rbx
movq %rsp, %r14
cmpq %r12, %r15
je 0x2ffaa
movq (%r15), %rdi
movq %rdi, (%rsp)
movq %rbx, %rsi
callq 0x2ea4f
testb %al, %al
jne 0x2ffc0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x930e
addq $0x8, %r15
jmp 0x2ff81
leaq 0x8(%rsp), %rdi
callq 0x15420
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x29fd1(%rip), %rdi     # 0x59f98
leaq 0xd65f(%rip), %rsi      # 0x3d62d
callq 0x63a0
leaq 0xd671(%rip), %rsi      # 0x3d64b
movq %rax, %rdi
callq 0x63a0
movq (%rsp), %rcx
movl (%rcx), %esi
movq %rax, %rdi
callq 0x6630
leaq 0xa56c(%rip), %rsi      # 0x3a563
movq %rax, %rdi
callq 0x63a0
pushq $0x1
popq %rdi
callq 0x6450
jmp 0x3000d
jmp 0x3000d
jmp 0x3000d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x15420
movq %rbx, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::SHORTEST_PATH(Agent*, Node*)
Nodes PPS::SHORTEST_PATH(Agent* c, Node* g) {
  if (H.empty()) return G->getPath(c->getNode(), g);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq 0x128(%rsi), %r14
movq 0x130(%rsi), %r15
cmpq %r15, %r14
je 0x300b9
movq %rdx, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r13
movaps %xmm0, (%r13)
andq $0x0, 0x10(%r13)
leaq 0x18(%rsp), %rbp
cmpq %r15, %r14
je 0x3008c
movq (%r14), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1aca4
addq $0x8, %r14
jmp 0x3006a
movq 0x38(%r12), %rsi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdx
movq (%rsi), %rax
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movq 0x10(%rsp), %rcx
callq *0x20(%rax)
leaq 0x20(%rsp), %rdi
callq 0x990e
jmp 0x300cb
movq 0x38(%r12), %rsi
movq 0x8(%rdx), %rdx
movq (%rsi), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x300df
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x990e
movq %rbx, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::SWAP_PRIMITIVES(S*)
void PPS::SWAP_PRIMITIVES(S* s) {
  // error check
  if (s->phase != SWAPPHASE::EVAC_H &&
      s->phase != SWAPPHASE::EVAC_L &&
      s->phase != SWAPPHASE::SWAP_DONE) {
    std::cout << "error@PPS::SWAP_PRIMITIVES, "
              << "invalid phase was called" << "\n";
    std::exit(1);
  }
  if (s->agents.size() != 2) {
    std::cout << "error@PPS::SWAP_PRIMITIVES, "
              << "the size of agents must be 2, not "
              <<  s->agents.size() << "\n";
    std::exit(1);
  }

  Agent* aH = s->agents[0];
  Agent* aL = s->agents[1];

  if (inArray(aH, M) || inArray(aL, M)) {
    M.push_back(aH);
    M.push_back(aL);
    return;
  }

  switch (s->phase) {
  case SWAPPHASE::EVAC_H:
    aH->setNode(s->evacH);
    aL->setNode(s->target);
    s->phase = SWAPPHASE::EVAC_L;
    break;
  case SWAPPHASE::EVAC_L:
    aH->setNode(s->target);
    aL->setNode(s->evacL);
    s->phase = SWAPPHASE::SWAP_DONE;
    break;
  case SWAPPHASE::SWAP_DONE:
    aH->setNode(s->origin);
    aL->setNode(s->target);
    FINISH_SWAP(s);
    break;
  default:
    break;
  }
  M.push_back(aH);
  M.push_back(aL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl 0x78(%rsi), %eax
addl $-0x2, %eax
cmpl $0x3, %eax
jae 0x30202
movq %rsi, %rbx
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rcx
subq %rax, %rcx
cmpq $0x10, %rcx
jne 0x30226
movq %rdi, %r12
movq (%rax), %r13
movq %r13, 0x8(%rsp)
movq 0x8(%rax), %r15
movq %r15, (%rsp)
leaq 0xe0(%rdi), %r14
movq %r13, %rdi
movq %r14, %rsi
callq 0x2ea4f
testb %al, %al
jne 0x30160
movq %r15, %rdi
movq %r14, %rsi
callq 0x2ea4f
testb %al, %al
je 0x30186
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x930e
movq %rsp, %rsi
movq %r14, %rdi
callq 0x930e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl 0x78(%rbx), %eax
cmpl $0x4, %eax
je 0x301da
cmpl $0x3, %eax
je 0x301b9
cmpl $0x2, %eax
jne 0x30160
movq 0x50(%rbx), %rsi
movq %r13, %rdi
callq 0x158b4
movq 0x40(%rbx), %rsi
movq %r15, %rdi
callq 0x158b4
movl $0x3, 0x78(%rbx)
jmp 0x30160
movq 0x40(%rbx), %rsi
movq %r13, %rdi
callq 0x158b4
movq 0x58(%rbx), %rsi
movq %r15, %rdi
callq 0x158b4
movl $0x4, 0x78(%rbx)
jmp 0x30160
movq 0x48(%rbx), %rsi
movq %r13, %rdi
callq 0x158b4
movq 0x40(%rbx), %rsi
movq %r15, %rdi
callq 0x158b4
movq %r12, %rdi
movq %rbx, %rsi
callq 0x30da4
jmp 0x30160
movq 0x29d8f(%rip), %rdi     # 0x59f98
leaq 0xd545(%rip), %rsi      # 0x3d755
callq 0x63a0
leaq 0xd556(%rip), %rsi      # 0x3d772
movq %rax, %rdi
callq 0x63a0
jmp 0x3025c
movq 0x29d6b(%rip), %rdi     # 0x59f98
leaq 0xd521(%rip), %rsi      # 0x3d755
callq 0x63a0
leaq 0xd54b(%rip), %rsi      # 0x3d78b
movq %rax, %rdi
callq 0x63a0
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
sarq $0x3, %rsi
movq %rax, %rdi
callq 0x6100
leaq 0xa300(%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/solver/pps.cpp
// Function: PPS::FINISH_SWAP(S*)
void PPS::FINISH_SWAP(S* s) {
  // error check
  if (s->agents.size() != 2) {
    std::cout << "error@PPS::FINISH_SWAP, the number of agetns is not two" << "\n";
    std::exit(1);
  }

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
movq 0x10(%rsi), %rax
subq 0x8(%rsi), %rax
cmpq $0x10, %rax
jne 0x30e9a
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x110(%rdi), %r15
movq 0x110(%rdi), %rdi
movq 0x118(%rbx), %rsi
leaq 0x40(%r14), %rdx
callq 0x15de1
movq %r15, %rdi
movq %rax, %rsi
callq 0x2d9b6
movq 0x110(%rbx), %rdi
movq 0x118(%rbx), %rsi
leaq 0x48(%r14), %rdx
callq 0x15de1
movq %r15, %rdi
movq %rax, %rsi
callq 0x2d9b6
movq 0x110(%rbx), %rdi
movq 0x118(%rbx), %rsi
leaq 0x50(%r14), %rdx
callq 0x15de1
movq %r15, %rdi
movq %rax, %rsi
callq 0x2d9b6
movq 0x110(%rbx), %rdi
movq 0x118(%rbx), %rsi
leaq 0x58(%r14), %rdx
callq 0x15de1
movq %r15, %rdi
movq %rax, %rsi
callq 0x2d9b6
leaq 0xb0(%rbx), %r15
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x930e
movq 0x8(%r14), %rsi
addq $0x8, %rsi
movq %r15, %rdi
callq 0x930e
addq $0xc8, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x31606
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x290f7(%rip), %rdi     # 0x59f98
leaq 0xc935(%rip), %rsi      # 0x3d7dd
callq 0x63a0
leaq 0x96af(%rip), %rsi      # 0x3a563
movq %rax, %rdi
callq 0x63a0
pushq $0x1
popq %rdi
callq 0x6450
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::getSortedEsv(Agent*)
Nodes PPS::getSortedEsv(Agent* c) {
  Nodes lst = deg3nodes;
  Graph* _G = G;
  Node* v = c->getNode();
  // actually, should use pathDist, but for fast implementation
  std::sort(lst.begin(), lst.end(),
            [_G, v] (Node* v1, Node* v2)
            { return _G->dist(v, v1) < _G->dist(v, v2); });
  return lst;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
addq $0x188, %rsi            # imm = 0x188
callq 0x15d3a
movq (%rbx), %r13
movq 0x8(%rbx), %r14
cmpq %r14, %r13
je 0x30f6f
movq 0x38(%r15), %r15
movq 0x8(%r12), %r12
movq %r14, %rbp
subq %r13, %rbp
movq %rbp, %rax
sarq $0x3, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rcx
movq %r12, %r8
callq 0x310d4
cmpq $0x81, %rbp
jl 0x30f5e
leaq 0x80(%r13), %rbp
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x3143e
cmpq %r14, %rbp
je 0x30f6f
movq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x314d8
addq $0x8, %rbp
jmp 0x30f45
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x3143e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x30f83
movq %rax, %r14
movq %rbx, %rdi
callq 0x990e
movq %r14, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::isFree(Node*)
bool PPS::isFree(Node* v) {
  bool flg = std::none_of(A.begin(), A.end(),
                          [v](Agent* a) { return a->getNode() == v; });
  flg &= !inArray(v, L);
  return flg;
}

// Assembly:
pushq %rbx
movq %rdi, %rax
movq 0x20(%rdi), %rdx
movq 0x28(%rdi), %rcx
movq %rcx, %rdi
subq %rdx, %rdi
movq %rdi, %r8
sarq $0x5, %r8
testq %r8, %r8
jle 0x30fe8
movq (%rdx), %r9
cmpq %rsi, 0x8(%r9)
je 0x31038
movq 0x8(%rdx), %r9
cmpq %rsi, 0x8(%r9)
je 0x31028
movq 0x10(%rdx), %r9
cmpq %rsi, 0x8(%r9)
je 0x3102e
movq 0x18(%rdx), %r9
cmpq %rsi, 0x8(%r9)
je 0x31034
addq $0x20, %rdx
decq %r8
addq $-0x20, %rdi
jmp 0x30faf
sarq $0x3, %rdi
cmpq $0x1, %rdi
je 0x3101b
cmpq $0x2, %rdi
je 0x3100e
movq %rcx, %r8
cmpq $0x3, %rdi
jne 0x3103b
movq (%rdx), %rdi
cmpq %rsi, 0x8(%rdi)
je 0x31038
addq $0x8, %rdx
movq (%rdx), %rdi
cmpq %rsi, 0x8(%rdi)
je 0x31038
addq $0x8, %rdx
movq (%rdx), %rdi
cmpq %rsi, 0x8(%rdi)
cmovneq %rcx, %rdx
jmp 0x31038
addq $0x8, %rdx
jmp 0x31038
addq $0x10, %rdx
jmp 0x31038
addq $0x18, %rdx
movq %rdx, %r8
cmpq %rcx, %r8
sete %bl
addq $0x110, %rax            # imm = 0x110
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2fc19
xorb $0x1, %al
andb %bl, %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/pps.cpp
// Function: PPS::logStr[abi:cxx11]()
std::string PPS::logStr() {
  std::string str;
  str += "[solver] type:Parallel Push & Swap\n";
  str += Solver::logStr();
  return str;
}

// Assembly:
pushq %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 0xc859(%rip), %rsi      # 0x3d8d5
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 0x310c4
jmp 0x310c1
movq %rax, %r14
movq %rbx, %rdi
callq 0x61d0
movq %r14, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/solver.cpp
// Function: Solver::init()
void Solver::init() {
  G = P->getG();
  A = P->getA();
  int nodeNum = G->getNodesNum();
  dists = Eigen::MatrixXi::Zero(nodeNum, nodeNum);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq 0x10(%rsi), %rax
movq %rax, 0x38(%rdi)
addq $0x18, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x934a
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x2324a
movq %r14, %rdi
callq 0x15420
movq 0x38(%rbx), %rax
movq 0x18(%rax), %rcx
subq 0x10(%rax), %rcx
shrq $0x3, %rcx
movslq %ecx, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x331e6
addq $0x40, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33376
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/solver.cpp
// Function: Solver::WarshallFloyd()
void Solver::WarshallFloyd() {
  int nodeNum = G->getNodesNum();
  Nodes neighbor;
  int INF = 100000;
  dists = Eigen::MatrixXi::Ones(nodeNum, nodeNum) * INF;

  // initialize weight
  for (int i = 0; i < nodeNum; ++i) {
    neighbor = G->neighbor(G->getNodeFromIndex(i));
    for (auto v : neighbor) {
      dists(i, v->getIndex()) = 1;
    }
    dists(i, i) = 0;
  }

  // main loop
  for (int k = 0; k < nodeNum; ++k) {
    for (int i = 0; i < nodeNum; ++i) {
      for (int j = 0; j < nodeNum; ++j) {
        if (dists(i, j) > dists(i, k) + dists(k, j)) {
          dists(i, j) = dists(i, k) + dists(k, j);
        }
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r14
movq 0x38(%rdi), %rax
movq 0x18(%rax), %r12
subq 0x10(%rax), %r12
shrq $0x3, %r12
andq $0x0, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movl $0x186a0, 0x14(%rsp)    # imm = 0x186A0
movslq %r12d, %rdx
leaq 0x40(%rsp), %rdi
movq %rdx, %rsi
callq 0x33204
leaq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x14(%rsp), %rdx
callq 0x33226
leaq 0x40(%r14), %rbx
leaq 0x58(%rsp), %rsi
movq %rbx, %rdi
callq 0x335af
xorl %r15d, %r15d
testl %r12d, %r12d
movl $0x0, %eax
movq %r12, 0x8(%rsp)
cmovgl %r12d, %eax
movq %rax, 0x18(%rsp)
leaq 0x58(%rsp), %r12
cmpq 0x18(%rsp), %r15
je 0x32ac3
movq 0x38(%r14), %rsi
movq 0x10(%rsi), %rax
movq (%rax,%r15,8), %rdx
movq %r12, %rdi
callq 0x164ca
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x18466
movq %r12, %rdi
callq 0x990e
movq 0x20(%rsp), %rbp
movq 0x28(%rsp), %r13
cmpq %r13, %rbp
je 0x32aad
movq (%rbp), %rax
movslq 0x4(%rax), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x33276
movl $0x1, (%rax)
addq $0x8, %rbp
jmp 0x32a89
movq %rbx, %rdi
movq %r15, %rsi
movq %r15, %rdx
callq 0x33276
andl $0x0, (%rax)
incq %r15
jmp 0x32a4f
movl 0x8(%rsp), %eax
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
cmpq 0x18(%rsp), %r14
je 0x32b73
xorl %r15d, %r15d
cmpq 0x8(%rsp), %r15
je 0x32b6b
xorl %r12d, %r12d
cmpq %r12, 0x8(%rsp)
je 0x32b63
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x33276
movl (%rax), %ebp
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x33276
movl (%rax), %r13d
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x33276
addl (%rax), %r13d
cmpl %r13d, %ebp
jle 0x32b5e
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x33276
movl (%rax), %ebp
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x33276
movl (%rax), %r13d
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x33276
addl %ebp, %r13d
movl %r13d, (%rax)
incq %r12
jmp 0x32aeb
incq %r15
jmp 0x32add
incq %r14
jmp 0x32acf
leaq 0x20(%rsp), %rdi
callq 0x990e
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x32b97
jmp 0x32b97
jmp 0x32b97
jmp 0x32b97
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x990e
movq %rbx, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/solver.cpp
// Function: Solver::formalizePath(std::vector<std::vector<Node*, std::allocator<Node*>>, std::allocator<std::vector<Node*, std::allocator<Node*>>>>&)
void Solver::formalizePath(Paths& paths) {
  int maxLength = getMaxLengthPaths(paths);
  Node* g;
  for (int i = 0; i < paths.size(); ++i) {
    g = paths[i][paths[i].size() - 1];
    while (paths[i].size() != maxLength) paths[i].push_back(g);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x32bac
movslq %eax, %r15
movq (%rbx), %rdi
xorl %r12d, %r12d
pushq $0x18
popq %r13
movq %rsp, %r14
movq 0x8(%rbx), %rax
subq %rdi, %rax
cqto
idivq %r13
cmpq %r12, %rax
jbe 0x32cc4
imulq $0x18, %r12, %rbp
movq 0x8(%rdi,%rbp), %rax
movq -0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rdi,%rbp), %rax
subq (%rdi,%rbp), %rax
sarq $0x3, %rax
cmpq %r15, %rax
je 0x32cbf
addq %rbp, %rdi
movq %r14, %rsi
callq 0x171da
movq (%rbx), %rdi
jmp 0x32c9d
incq %r12
jmp 0x32c7b
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/solver/solver.cpp
// Function: Solver::getKey[abi:cxx11](int, Node*)
std::string Solver::getKey(int t, Node* v) {
  std::string key = "";
  key += std::to_string(t);
  key += "-";
  key += std::to_string(v->getId());
  return key;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x7601(%rip), %rsi      # 0x3a564
movq %rsp, %rdx
callq 0x92b0
movq %rsp, %rdi
movl %ebp, %esi
callq 0x943e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x66c0
movq %rsp, %rdi
callq 0x61d0
leaq 0xb3d8(%rip), %rsi      # 0x3e367
movq %rbx, %rdi
callq 0x66a0
movl (%r14), %esi
movq %rsp, %rdi
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 0x32fc7
jmp 0x32fd4
jmp 0x32fd4
movq %rax, %r14
movq %rsp, %rdi
callq 0x61d0
jmp 0x32fd7
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/solver/solver.cpp
// Function: Solver::logStr[abi:cxx11]()
std::string Solver::logStr() {
  std::string str;

  str += "[solver] solved:" + std::to_string(P->isSolved()) + "\n";
  str += "[solver] elapsed:" + std::to_string((int)elapsedTime) + "\n";
  str += "[solver] makespan:" + std::to_string(P->getTerminationTime()) + "\n";
  str += P->logStr();

  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 0x10(%rsi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movzbl %al, %esi
leaq 0x28(%rsp), %rdi
callq 0x943e
leaq 0xa9c3(%rip), %rsi      # 0x3d9fc
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x941a
leaq 0x7514(%rip), %rdx      # 0x3a563
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x93fb
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
leaq 0x48(%rsp), %rdi
callq 0x61d0
leaq 0x28(%rsp), %rdi
callq 0x61d0
cvttsd2si 0x8(%r14), %esi
leaq 0x28(%rsp), %rdi
callq 0x943e
leaq 0x74b0(%rip), %rsi      # 0x3a550
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x941a
leaq 0x74ad(%rip), %rdx      # 0x3a563
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x93fb
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
leaq 0x48(%rsp), %rdi
callq 0x61d0
leaq 0x28(%rsp), %rdi
callq 0x61d0
movq 0x10(%r14), %rax
movl 0x8(%rax), %esi
leaq 0x28(%rsp), %rdi
callq 0x943e
leaq 0xa905(%rip), %rsi      # 0x3da0d
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x941a
leaq 0x7445(%rip), %rdx      # 0x3a563
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x93fb
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
leaq 0x48(%rsp), %rdi
callq 0x61d0
leaq 0x28(%rsp), %rdi
callq 0x61d0
movq 0x10(%r14), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x30(%rax)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x331cb
jmp 0x331d2
jmp 0x331a5
jmp 0x331b4
jmp 0x331c3
jmp 0x331d2
jmp 0x331a5
jmp 0x331b4
jmp 0x331c3
jmp 0x331d2
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x61d0
jmp 0x331b7
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x61d0
jmp 0x331c6
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x61d0
jmp 0x331d5
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/solver/tp.cpp
// Function: TP::init()
void TP::init() {
  timestep = 0;
  status = true;
  P->setAutoAssignement(false);

  G->setRegFlg(true);

  // initialize
  for (auto a : A) paths.push_back({ a->getNode() });
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
andl $0x0, 0x68(%rdi)
movb $0x1, %bpl
movb %bpl, 0xa0(%rdi)
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x28(%rax)
movq 0x38(%rbx), %rax
movb %bpl, 0x9(%rax)
movq 0x20(%rbx), %rbp
movq 0x28(%rbx), %r15
addq $0x88, %rbx
leaq 0x10(%rsp), %r14
pushq $0x1
popq %r12
leaq 0x7(%rsp), %r13
cmpq %r15, %rbp
je 0x33876
movq (%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x927a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x15146
movq %r14, %rdi
callq 0x990e
addq $0x8, %rbp
jmp 0x33838
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x990e
movq %rbx, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/tp.cpp
// Function: TP::solve()
bool TP::solve() {
  solveStart();

  while (!P->isSolved()) {
    ++timestep;
    update();

    if (!status) {
      solveEnd();
      return false;  // failed
    }

    P->update();
    if (P->getTimestep() >= P->getTimestepLimit()) break;
  }

  solveEnd();
  return true;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
callq *(%rax)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movb $0x1, %bpl
testb %al, %al
jne 0x339d8
incl 0x68(%rbx)
movq %rbx, %rdi
callq 0x339ea
cmpb $0x1, 0xa0(%rbx)
jne 0x339d6
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rbx), %rdi
movl 0x8(%rdi), %eax
cmpl 0xc(%rdi), %eax
jl 0x3399d
jmp 0x339d8
xorl %ebp, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/tp.cpp
// Function: TP::update()
void TP::update() {
  Agent* a;
  Node* v;
  Task* tau;
  std::vector<Task*> tasks;

  for (int i = 0; i < A.size(); ++i) {
    a = A[i];

    if (paths[i].size() <= timestep) {
      v = a->getNode();
      tasks = getExecutableTask(a, timestep);  // l.7

      if (!tasks.empty()) {  // l.8
        tau = getNearestTask(a, tasks);  // l.9

        a->setTask(tau);  // l.10
        P->assign(tau);   // l.11
        if (tau->getG()[0] == a->getNode()) {  // when current place is pickup node
          tau->update(a->getNode());
        }

        updatePath1(a, timestep);  // l.12
      } else if (!shouldAvoid(a, timestep)) {  // l.13
        paths[i].push_back(v);  // l.14
      } else {
        updatePath2(a, timestep);  // l.16
      }
    }

    a->setNode(paths[i][timestep]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, (%r15)
andq $0x0, 0x10(%r15)
xorl %r12d, %r12d
leaq 0x40(%rsp), %r14
xorl %esi, %esi
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rsi, %rcx
jbe 0x33b5d
movq 0x88(%rbx), %rcx
movq 0x8(%rcx,%r12), %rdx
subq (%rcx,%r12), %rdx
movq %rsi, 0x10(%rsp)
movq (%rax,%rsi,8), %r13
sarq $0x3, %rdx
movslq 0x68(%rbx), %rax
cmpq %rax, %rdx
ja 0x33b31
movq 0x8(%r13), %rax
movq %rax, 0x18(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x33b90
movq %r15, %rdi
movq %r14, %rsi
callq 0x3569e
movq %r14, %rdi
callq 0x154b6
movq 0x20(%rsp), %rax
cmpq 0x28(%rsp), %rax
je 0x33afe
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x33d84
movq %rax, %rbp
movq %rax, 0x18(%r13)
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x1ed7a
movq %r14, %rdi
movq %rbp, %rsi
callq 0x15d3a
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%r13), %rax
movq %rax, (%rsp)
movq %r14, %rdi
callq 0x990e
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
jne 0x33aee
movq 0x8(%r13), %rsi
movq %rbp, %rdi
callq 0x39324
movl 0x68(%rbx), %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x33e8e
jmp 0x33b31
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3402c
testb %al, %al
je 0x33b1d
movl 0x68(%rbx), %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x340f0
jmp 0x33b31
movq 0x88(%rbx), %rdi
addq %r12, %rdi
leaq 0x18(%rsp), %rsi
callq 0x171da
movq 0x88(%rbx), %rax
movslq 0x68(%rbx), %rcx
movq (%rax,%r12), %rax
movq (%rax,%rcx,8), %rsi
movq %r13, %rdi
callq 0x158b4
movq 0x10(%rsp), %rsi
incq %rsi
addq $0x18, %r12
jmp 0x33a16
leaq 0x20(%rsp), %rdi
callq 0x154b6
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x33b7a
jmp 0x33b7a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x154b6
movq %rbx, %rdi
callq 0x6650
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/tp.cpp
// Function: TP::getExecutableTask(Agent*, int)
bool TP::shouldAvoid(Agent* a, int timestep) {
  Node* v = a->getNode();
  Node* g;

  for (auto tau : P->getT()) {
    g = tau->getG()[tau->getG().size() - 1];  // delivery points
    if (g == v) return true;
  }
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movq %rdi, (%rsp)
movups %xmm0, (%rdi)
andq $0x0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq 0x8(%rdx), %rax
movq %rax, 0x38(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x10(%rsi), %rsi
addq $0x30, %rsi
leaq 0x40(%rsp), %rdi
callq 0x9398
movq 0x40(%rsp), %rbx
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x58(%rsp), %r12
leaq 0x70(%rsp), %r13
cmpq 0x30(%rsp), %rbx
je 0x33d1c
movq (%rbx), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x88(%rax), %r15
movq 0x90(%rax), %r14
cmpq %r14, %r15
je 0x33cfb
movq %r12, %rdi
movq %r15, %rsi
callq 0x15d3a
movq 0x60(%rsp), %rax
movq -0x8(%rax), %rbp
cmpq 0x38(%rsp), %rbp
je 0x33cea
movq 0x8(%rsp), %rsi
movq %r13, %rdi
callq 0x15d3a
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x18466
movq %r13, %rdi
callq 0x990e
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
movq %rdx, %rsi
sarq $0x5, %rsi
testq %rsi, %rsi
jle 0x33ca4
cmpq %rbp, (%rax)
je 0x33ce5
cmpq %rbp, 0x8(%rax)
je 0x33cd5
cmpq %rbp, 0x10(%rax)
je 0x33cdb
cmpq %rbp, 0x18(%rax)
je 0x33ce1
addq $0x20, %rax
decq %rsi
addq $-0x20, %rdx
jmp 0x33c7b
sarq $0x3, %rdx
cmpq $0x1, %rdx
je 0x33ccc
cmpq $0x2, %rdx
je 0x33cc3
cmpq $0x3, %rdx
jne 0x33cea
cmpq %rbp, (%rax)
je 0x33ce5
addq $0x8, %rax
cmpq %rbp, (%rax)
je 0x33ce5
addq $0x8, %rax
cmpq %rbp, (%rax)
cmovneq %rcx, %rax
jmp 0x33ce5
addq $0x8, %rax
jmp 0x33ce5
addq $0x10, %rax
jmp 0x33ce5
addq $0x18, %rax
cmpq %rcx, %rax
jne 0x33d0b
movq %r12, %rdi
callq 0x990e
addq $0x18, %r15
jmp 0x33c1a
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x932c
jmp 0x33d13
movq %r12, %rdi
callq 0x990e
addq $0x8, %rbx
jmp 0x33bf4
leaq 0x40(%rsp), %rdi
callq 0x154b6
leaq 0x10(%rsp), %rdi
callq 0x990e
movq (%rsp), %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x33d69
jmp 0x33d5c
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x990e
jmp 0x33d5f
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x154b6
leaq 0x10(%rsp), %rdi
callq 0x990e
movq (%rsp), %rdi
callq 0x154b6
movq %r14, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/tp.cpp
// Function: TP::updatePath1(Agent*, int)
void TP::updatePath1(Agent* a, int startTime) {
  auto itr = std::find(A.begin(), A.end(), a);
  int i = std::distance(A.begin(), itr);

  Nodes gs = a->getTask()->getG();
  a->setGoal(gs[gs.size() - 1]);  // delivery point

  Nodes p;
  Nodes path = { a->getNode() };

  if (gs.size() == 2) {
    path = getPickDelivPath(a, a->getNode(), gs[0], gs[1], startTime, true);
  } else if (gs.size() == 1) {
    path = getPath(a, a->getNode(), gs[0], startTime, gs[0]);
  }

  paths[i].insert(paths[i].end(), path.begin() + 1, path.end());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movl %edx, %r15d
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %rsi, (%r12)
movq 0x20(%rdi), %rdi
movq 0x28(%rbx), %rsi
movq %r12, %rdx
callq 0x2dcba
movq %rax, %r14
subq 0x20(%rbx), %r14
movq (%r12), %rax
movq 0x18(%rax), %rsi
leaq 0x48(%rsp), %r13
movq %r13, %rdi
callq 0x15d3a
movq (%r12), %rax
movq 0x8(%r13), %rcx
movq -0x8(%rcx), %rcx
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
andq $0x0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movq 0x8(%rax), %rax
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x18(%rsp), %rdi
pushq $0x1
popq %rdx
leaq 0xf(%rsp), %rcx
callq 0x927a
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq $0x1, %rcx
je 0x33f57
cmpq $0x2, %rcx
jne 0x33f9c
movq 0x10(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq (%rax), %r8
movq 0x8(%rax), %r9
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
pushq $0x1
pushq %r15
callq 0x34516
popq %rax
popq %rcx
jmp 0x33f82
movq 0x10(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq (%rax), %r8
xorl %eax, %eax
testq %r8, %r8
setne %al
subq $0x8, %rsp
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
movl %r15d, %r9d
pushq %rax
callq 0x34c94
popq %rax
popq %rcx
leaq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %r15
movq %r15, %rsi
callq 0x18466
movq %r15, %rdi
callq 0x990e
shrq $0x3, %r14
movslq %r14d, %rax
movq 0x88(%rbx), %rcx
imulq $0x18, %rax, %rax
leaq (%rcx,%rax), %rdi
movq 0x8(%rcx,%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
addq $0x8, %rdx
callq 0x35502
leaq 0x18(%rsp), %rdi
callq 0x990e
leaq 0x60(%rsp), %rdi
callq 0x990e
leaq 0x48(%rsp), %rdi
callq 0x990e
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x33ffd
jmp 0x33ffd
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x990e
jmp 0x3400f
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x990e
leaq 0x48(%rsp), %rdi
callq 0x990e
movq %rbx, %rdi
callq 0x6650
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/tp.cpp
// Function: TP::logStr[abi:cxx11]()
std::string TP::logStr() {
  std::string str;
  str += "[solver] type:TP\n";
  str += Solver::logStr();
  return str;
}

// Assembly:
pushq %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 0x8f3d(%rip), %rsi      # 0x3e33f
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 0x3544a
jmp 0x35447
movq %rax, %r14
movq %rbx, %rdi
callq 0x61d0
movq %r14, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/whca.cpp
// Function: WHCA::logStr[abi:cxx11]()
std::string WHCA::logStr() {
  std::string str;
  str += "[solver] type:WHCA-" + std::to_string(window) + "\n";
  str += Solver::logStr();
  return str;
}

// Assembly:
pushq %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)
movl 0x6c(%rsi), %esi
leaq 0x28(%rsp), %rdi
callq 0x943e
leaq 0x6f12(%rip), %rsi      # 0x3e355
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x941a
leaq 0x310a(%rip), %rdx      # 0x3a563
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x93fb
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
leaq 0x48(%rsp), %rdi
callq 0x61d0
leaq 0x28(%rsp), %rdi
callq 0x61d0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x32ffe
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x374f4
jmp 0x374fb
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x61d0
jmp 0x374e0
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x61d0
jmp 0x374ef
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x61d0
jmp 0x374fe
movq %rax, %r14
movq %rbx, %rdi
callq 0x61d0
movq %r14, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/winpibt.cpp
// Function: winPIBT::init()
void winPIBT::init() {
  G->setRegFlg(true);

  // initialize priroirty and paths
  int agentNum = A.size();
  for (int i = 0; i < agentNum; ++i) {
    epsilon.push_back((float)i / agentNum);
    eta.push_back(0);
    priority.push_back(epsilon[i] + eta[i]);
    PATHS.push_back({A[i]->getNode()});
    L.push_back(0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movb $0x1, 0x9(%rax)
movq 0x28(%rdi), %r15
subq 0x20(%rdi), %r15
shrq $0x3, %r15
leaq 0xa0(%rdi), %rax
movq %rax, 0x20(%rsp)
cvtsi2ss %r15d, %xmm0
movss %xmm0, 0xc(%rsp)
leaq 0xb8(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0xd0(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x70(%rdi), %r13
leaq 0x88(%rdi), %rbp
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
leaq 0x30(%rsp), %r14
cmpq %r12, %r15
je 0x3789b
cvtsi2ss %r12d, %xmm0
divss 0xc(%rsp), %xmm0
movss %xmm0, 0x30(%rsp)
movq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x2da4e
andl $0x0, 0x30(%rsp)
movq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x1d402
movq 0xb8(%rbx), %rax
cvtsi2ssl (%rax,%r12,4), %xmm0
movq 0xa0(%rbx), %rax
addss (%rax,%r12,4), %xmm0
movss %xmm0, 0x30(%rsp)
movq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x2da4e
movq 0x20(%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq %r14, %rdi
leaq 0x28(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0xb(%rsp), %rcx
callq 0x927a
movq %r13, %rdi
movq %r14, %rsi
callq 0x15146
movq %r14, %rdi
callq 0x990e
andl $0x0, 0x30(%rsp)
movq %rbp, %rdi
movq %r14, %rsi
callq 0x1d402
incq %r12
jmp 0x377e4
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x990e
movq %rbx, %rdi
callq 0x6650
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/winpibt.cpp
// Function: winPIBT::checkValidPath(int, std::vector<Node*, std::allocator<Node*>>&, int, int)
bool winPIBT::checkValidPath(int id, Nodes &path, int t1, int t2) {
  int k;
  Node *v1, *v2;

  for (int j = 1; j < path.size(); ++j) {
    v1 = path[j-1];
    v2 = path[j];
    for (int i = 0; i < A.size(); ++i) {
      if (id == i) continue;

      k = ell(i);
      for (int _t = j + t1 + 1; _t <= t2; ++_t) {
        if (k < _t) break;
        if (PATHS[i][_t] == v2) {  // vertex collision
          return false;
        }
      }

      if (PATHS[i].size() - 1 < j + t1) continue;
      if (PATHS[i][j + t1] == v2) {  // collision
        return false;
      }
      if (v1 == PATHS[i][j + t1] && v2 == PATHS[i][j + t1 - 1]) {
        return false;
      }

    }
  }

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdx), %r9
movq 0x8(%rdx), %rax
subq %r9, %rax
sarq $0x3, %rax
movq 0x28(%rdi), %rdx
movq 0x70(%rdi), %r10
movq %r10, -0x8(%rsp)
subq 0x20(%rdi), %rdx
sarq $0x3, %rdx
movq 0x88(%rdi), %rdi
movq %rdi, -0x10(%rsp)
movl %esi, %esi
movslq %ecx, %rdi
movq %rdi, -0x18(%rsp)
movabsq $0x1, %r11
cmpq %r11, %rax
jbe 0x38c0f
incl %ecx
movslq %ecx, %r10
movq -0x8(%r9,%r11,8), %rdi
movq %rdi, -0x20(%rsp)
movq (%r9,%r11,8), %r12
movq -0x18(%rsp), %rdi
addq %r11, %rdi
movq %rdi, -0x28(%rsp)
xorl %ebp, %ebp
cmpq %rdx, %rbp
je 0x38c07
cmpq %rsi, %rbp
je 0x38c02
movq -0x10(%rsp), %rdi
movl (%rdi,%rbp,4), %r14d
cmpl %r14d, %r8d
cmovll %r8d, %r14d
imulq $0x18, %rbp, %rbx
addq -0x8(%rsp), %rbx
movslq %r14d, %r15
movq %r10, %r14
cmpq %r15, %r14
jge 0x38bc9
leaq 0x1(%r14), %rdi
movq (%rbx), %r13
cmpq %r12, 0x8(%r13,%r14,8)
movq %rdi, %r14
jne 0x38bb1
jmp 0x38c0f
movq (%rbx), %r15
movq 0x8(%rbx), %rdi
subq %r15, %rdi
sarq $0x3, %rdi
decq %rdi
cmpq -0x28(%rsp), %rdi
jb 0x38c02
movq -0x28(%rsp), %rdi
movq (%r15,%rdi,8), %rbx
cmpq %r12, %rbx
je 0x38c0f
cmpq %rbx, -0x20(%rsp)
jne 0x38c02
movq -0x28(%rsp), %rdi
cmpq -0x8(%r15,%rdi,8), %r12
je 0x38c0f
incq %rbp
jmp 0x38b88
incq %r11
jmp 0x38b5d
cmpq %r11, %rax
setbe %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/winpibt.cpp
// Function: winPIBT::logStr[abi:cxx11]()
std::string winPIBT::logStr() {
  std::string str;
  str += "[solver] type:winPIBT-" + std::to_string(w) + "\n";
  str += "[solver] softmode:" + std::to_string(softmode) + "\n";
  str += Solver::logStr();
  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)
movl 0x68(%rsi), %esi
leaq 0x28(%rsp), %rdi
callq 0x943e
leaq 0x574e(%rip), %rsi      # 0x3e39f
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x941a
leaq 0x18fc(%rip), %rdx      # 0x3a563
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x93fb
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
leaq 0x48(%rsp), %rdi
callq 0x61d0
leaq 0x28(%rsp), %rdi
callq 0x61d0
movzbl 0x6c(%r14), %esi
leaq 0x28(%rsp), %rdi
callq 0x943e
leaq 0x56ff(%rip), %rsi      # 0x3e3b6
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x941a
leaq 0x1896(%rip), %rdx      # 0x3a563
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x93fb
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
leaq 0x48(%rsp), %rdi
callq 0x61d0
leaq 0x28(%rsp), %rdi
callq 0x61d0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x32ffe
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66c0
leaq 0x8(%rsp), %rdi
callq 0x61d0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x38d70
jmp 0x38d77
jmp 0x38d4a
jmp 0x38d59
jmp 0x38d68
jmp 0x38d77
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x61d0
jmp 0x38d5c
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x61d0
jmp 0x38d6b
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x61d0
jmp 0x38d7a
movq %rax, %r14
movq %rbx, %rdi
callq 0x61d0
movq %r14, %rdi
callq 0x6650
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/task/task.cpp
// Function: Task::Task(Node*)
Task::Task(Node* v) : id(cntId) {
  ++cntId;
  startTime = 0;
  endTime = 0;
  G_OPEN.push_back(v);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rax
movq %rsi, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl 0x21669(%rip), %ecx     # 0x5a81c
movl %ecx, 0x30(%rdi)
incl %ecx
movl %ecx, 0x2165e(%rip)     # 0x5a81c
andq $0x0, 0x34(%rdi)
movq %rax, %rsi
callq 0x171da
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x18(%rbx), %rdi
callq 0x990e
movq %rbx, %rdi
callq 0x990e
movq %r14, %rdi
callq 0x6650
nop
// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/task/task.cpp
// Function: Task::Task(Node*, int)
Task::Task(Node* v, int t) : id(cntId) {
  ++cntId;
  startTime = t;
  endTime = 0;
  G_OPEN.push_back(v);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rax
movq %rsi, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl 0x215e3(%rip), %ecx     # 0x5a81c
movl %ecx, 0x30(%rdi)
incl %ecx
movl %ecx, 0x215d8(%rip)     # 0x5a81c
movl %edx, 0x34(%rdi)
andl $0x0, 0x38(%rdi)
movq %rax, %rsi
callq 0x171da
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x18(%rbx), %rdi
callq 0x990e
movq %rbx, %rdi
callq 0x990e
movq %r14, %rdi
callq 0x6650
nop