LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movslq 0x94(%rdi), %rax
movq %rax, -0x40(%rbp)
movslq 0x90(%rdi), %rax
movq %rax, -0x48(%rbp)
addq $0x18, %rdi
callq 0x383b0
movq -0x48(%rbp), %rcx
movq %rax, %rdx
movq -0x40(%rbp), %rax
imulq %rdx, %rcx
cmpq %rcx, %rax
jae 0x52ecd
movb $0x0, -0x1(%rbp)
jmp 0x52f46
movq -0x50(%rbp), %rdi
addq $0x98, %rdi
callq 0x4f9b0
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x98, %rdi
callq 0x4f840
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x52f60
movq -0x50(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x98, %rdi
callq 0x4f840
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x53740
testb $0x1, %al
jne 0x52f3c
jmp 0x52f42
movb $0x0, -0x1(%rbp)
jmp 0x52f46
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Kei18[P]pibt/./src/problem/mapd.cpp
// Function: MAPD::init()
void MAPD::init() {
  taskCnt = 0;
  autoAssignment = true;
  --timestep;
  update();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x0, 0xc0(%rdi)
movb $0x1, 0xcc(%rdi)
movl 0x8(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rdi)
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movl 0xc0(%rcx), %eax
cmpl 0xc4(%rcx), %eax
jl 0x54442
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
callq 0x55570
testb $0x1, %al
jne 0x54405
jmp 0x54442
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x39b60
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x18, %rdi
callq 0x399f0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x54460
testb $0x1, %al
jne 0x5443a
jmp 0x54440
movb $0x1, -0x1(%rbp)
jmp 0x54446
jmp 0x54442
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl 0x8(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x8(%rdi)
callq 0x54560
movq -0x30(%rbp), %rdi
callq 0x546d0
movq -0x30(%rbp), %rax
testb $0x1, 0xcc(%rax)
je 0x544f1
movq -0x30(%rbp), %rdi
callq 0x54870
movq -0x30(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39b60
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x399f0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x51bd0
testb $0x1, %al
jne 0x5452a
jmp 0x5454e
leaq -0x18(%rbp), %rdi
callq 0x51c10
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3a6e0
leaq -0x18(%rbp), %rdi
callq 0x51c30
jmp 0x54517
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Kei18[P]pibt/./src/problem/mapd.cpp
// Function: MAPD::updateStatus()
void MAPD::updateStatus() {
  // update agent status
  for (auto a : A) {
    if (!a->hasTask()) continue;
    if (a->hasGoal()) {
      if (a->getTask()->getG()[0] == a->getNode()) {
        a->getTask()->update(a->getNode());
      }
    }
    if (a->getTask()->completed()) {
      a->getTask()->setEndTime(timestep);
      a->releaseTask();
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39b60
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x399f0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x51bd0
testb $0x1, %al
jne 0x545af
jmp 0x546ba
leaq -0x18(%rbp), %rdi
callq 0x51c10
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3ae30
testb $0x1, %al
jne 0x545d1
jmp 0x546ac
movq -0x28(%rbp), %rdi
callq 0x3ae10
testb $0x1, %al
jne 0x545e3
jmp 0x54672
movq -0x28(%rbp), %rdi
callq 0x51c90
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x51d30
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xda90
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rdi
callq 0x51cb0
movq %rax, -0x60(%rbp)
jmp 0x5461f
leaq -0x40(%rbp), %rdi
callq 0xd7d0
movq -0x60(%rbp), %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jne 0x54670
movq -0x28(%rbp), %rdi
callq 0x51c90
movq %rax, -0x78(%rbp)
movq -0x28(%rbp), %rdi
callq 0x51cb0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0xb1a70
jmp 0x54670
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xd7d0
jmp 0x546c3
jmp 0x54672
movq -0x28(%rbp), %rdi
callq 0x51c90
movq %rax, %rdi
callq 0xb1b50
testb $0x1, %al
jne 0x54689
jmp 0x546aa
movq -0x28(%rbp), %rdi
callq 0x51c90
movq %rax, %rdi
movq -0x58(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xb1b70
movq -0x28(%rbp), %rdi
callq 0x3a780
jmp 0x546ac
leaq -0x18(%rbp), %rdi
callq 0x51c30
jmp 0x54599
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x8880
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movl 0xc0(%rcx), %eax
cmpl 0xc4(%rcx), %eax
jl 0x546f7
jmp 0x5485a
movq -0x48(%rbp), %rax
movss 0xc8(%rax), %xmm0
movss 0x5fe2d(%rip), %xmm1    # 0xb4538
ucomiss %xmm1, %xmm0
jb 0x54721
movq -0x48(%rbp), %rax
cvttss2si 0xc8(%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x54756
movq -0x48(%rbp), %rcx
movl 0x8(%rcx), %eax
movss 0x5fe08(%rip), %xmm0    # 0xb4538
divss 0xc8(%rcx), %xmm0
cvttss2si %xmm0, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x5474d
movl $0x1, -0xc(%rbp)
jmp 0x54754
movl $0x0, -0xc(%rbp)
jmp 0x54756
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5485a
movq -0x48(%rbp), %rcx
movl 0xc0(%rcx), %eax
cmpl 0xc4(%rcx), %eax
jge 0x5484a
jmp 0x54781
movq -0x48(%rbp), %rax
movq %rax, %rdi
addq $0x90, %rdi
movq 0x60(%rax), %rsi
callq 0x54ba0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq %rax, %rdi
addq $0xa8, %rdi
movq 0x60(%rax), %rsi
callq 0x54ba0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x54781
movl $0x40, %edi
callq 0x84e0
movq %rax, %rdi
movq -0x48(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x50(%rbp)
movl 0x8(%rax), %esi
callq 0xb1840
jmp 0x547e6
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x555b0
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x555b0
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
leaq -0x30(%rbp), %rsi
callq 0xdb40
movq -0x48(%rbp), %rax
movl 0xc0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc0(%rax)
jmp 0x5484a
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x40, %esi
callq 0x84f0
jmp 0x54860
jmp 0x5484c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5475d
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x8880
nopl (%rax)
// File: Kei18[P]pibt/./src/problem/mapd.cpp
// Function: MAPD::autoAssign()
void MAPD::autoAssign() {
  for (auto a : A) {
    if (a->hasTask()) continue;
    for (auto tau : T_OPEN) {
      if (a->getNode() == tau->getG()[0]) {
        a->setTask(tau);
        if (tau->getG()[0] == a->getNode()) {
          tau->update(a->getNode());
        }
        a->setGoal(tau->getG()[0]);
        openToClose(tau, T_OPEN, T_CLOSE);
        break;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39b60
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x399f0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x51bd0
testb $0x1, %al
jne 0x548c2
jmp 0x54add
leaq -0x18(%rbp), %rdi
callq 0x51c10
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3ae30
testb $0x1, %al
jne 0x548e1
jmp 0x548e6
jmp 0x54acf
movq -0xa8(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3a140
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x39fd0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x51e40
testb $0x1, %al
jne 0x54925
jmp 0x54acd
leaq -0x38(%rbp), %rdi
callq 0x51e80
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
callq 0x51cb0
movq %rax, -0xb0(%rbp)
movq -0x48(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x51d30
leaq -0x60(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xda90
movq (%rax), %rax
movq %rax, -0xb8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xd7d0
movq -0xb8(%rbp), %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
jne 0x54abd
movq -0x28(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x51cf0
movq -0x48(%rbp), %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x51d30
movq -0xd0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xda90
movq (%rax), %rax
movq %rax, -0xc8(%rbp)
movq -0x28(%rbp), %rdi
callq 0x51cb0
movq %rax, -0xc0(%rbp)
jmp 0x549d6
leaq -0x78(%rbp), %rdi
callq 0xd7d0
movq -0xc0(%rbp), %rcx
movq -0xc8(%rbp), %rax
cmpq %rcx, %rax
jne 0x54a34
movq -0x48(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x28(%rbp), %rdi
callq 0x51cb0
movq -0xd8(%rbp), %rdi
movq %rax, %rsi
callq 0xb1a70
jmp 0x54a34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xd7d0
jmp 0x54ae6
movq -0x28(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x48(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x51d30
movq -0xe8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xda90
movq -0xe0(%rbp), %rdi
movq (%rax), %rsi
callq 0x51d10
jmp 0x54a77
leaq -0xa0(%rbp), %rdi
callq 0xd7d0
movq -0xa8(%rbp), %rdx
movq -0x48(%rbp), %rdi
movq %rdx, %rsi
addq $0x30, %rsi
addq $0x48, %rdx
callq 0x54af0
jmp 0x54acd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0xd7d0
jmp 0x54ae6
jmp 0x54abf
leaq -0x38(%rbp), %rdi
callq 0x51ea0
jmp 0x5490f
jmp 0x54acf
leaq -0x18(%rbp), %rdi
callq 0x51c30
jmp 0x548ac
addq $0xf0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x8880
nop
// File: Kei18[P]pibt/./src/problem/mapf.cpp
// Function: MAPF::init()
void MAPF::init() {
  // error check
  if (A.size() != T_OPEN.size()) {
    std::cout << "error@MAPF::init, this is not a MAPF, |A| != |T|" << "\n";
    std::exit(1);
  }

  // allocation, t=0
  for (int i = 0; i < A.size(); ++i) {
    A[i]->setTask(T_OPEN[i]);
    A[i]->setGoal(A[i]->getTask()->getG()[0]);
    A[i]->updateHist();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x18, %rdi
callq 0x383b0
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x30, %rdi
callq 0x38af0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
je 0x559a6
movq 0xab617(%rip), %rdi     # 0x100f98
leaq 0x5fd46(%rip), %rsi     # 0xb56ce
callq 0x84d0
movq %rax, %rdi
leaq 0x5dc20(%rip), %rsi     # 0xb35b7
callq 0x84d0
movl $0x1, %edi
callq 0x85d0
movl $0x0, -0xc(%rbp)
movq -0x48(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x18, %rdi
callq 0x383b0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x55aa6
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x68(%rbp)
movslq -0xc(%rbp), %rsi
callq 0x53720
movq -0x48(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x70(%rbp)
addq $0x30, %rdi
movslq -0xc(%rbp), %rsi
callq 0x56800
movq -0x70(%rbp), %rdi
movq (%rax), %rsi
callq 0x51cf0
movq -0x68(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x53720
movq -0x68(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movslq -0xc(%rbp), %rsi
callq 0x53720
movq (%rax), %rdi
callq 0x51c90
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x51d30
movq -0x60(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xda90
movq -0x58(%rbp), %rdi
movq (%rax), %rsi
callq 0x51d10
jmp 0x55a5f
leaq -0x28(%rbp), %rdi
callq 0xd7d0
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
movslq -0xc(%rbp), %rsi
callq 0x53720
movq (%rax), %rdi
callq 0x3a6e0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x559ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xd7d0
jmp 0x55aac
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x8880
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39b60
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x399f0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x51bd0
testb $0x1, %al
jne 0x55d28
jmp 0x55eb9
leaq -0x18(%rbp), %rdi
callq 0x51c10
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x51c90
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x55d9e
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rdi
callq 0x51cb0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0xb1a70
movq -0x30(%rbp), %rdi
callq 0xb1b50
testb $0x1, %al
jne 0x55d78
jmp 0x55d99
movq -0x28(%rbp), %rdi
callq 0x3a7a0
movq -0x68(%rbp), %rdx
movq -0x30(%rbp), %rdi
movq %rdx, %rsi
addq $0x30, %rsi
addq $0x48, %rdx
callq 0x55ed0
jmp 0x55ea2
movq -0x28(%rbp), %rdi
callq 0x51cb0
movq %rax, -0x78(%rbp)
movq -0x28(%rbp), %rdi
callq 0x56820
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
je 0x55ea0
movl $0x40, %edi
callq 0x84e0
movq %rax, -0x88(%rbp)
movq -0x28(%rbp), %rdi
callq 0x56820
movq %rax, -0x80(%rbp)
jmp 0x55de4
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdi
callq 0xb17b0
jmp 0x55df6
movq -0x88(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x51cf0
movq -0x28(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x51d30
movq -0x98(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xda90
movq -0x90(%rbp), %rdi
movq (%rax), %rsi
callq 0x51d10
jmp 0x55e4e
leaq -0x60(%rbp), %rdi
callq 0xd7d0
movq -0x68(%rbp), %rdi
addq $0x30, %rdi
leaq -0x38(%rbp), %rsi
callq 0xdb40
jmp 0x55ea0
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl $0x40, %esi
callq 0x84f0
jmp 0x55ec2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xd7d0
jmp 0x55ec2
jmp 0x55ea2
movq -0x28(%rbp), %rdi
callq 0x3a6e0
leaq -0x18(%rbp), %rdi
callq 0x51c30
jmp 0x55d12
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x8880
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq 0xa95b2(%rip), %rcx     # 0x1009d0
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39b60
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x399f0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x51bd0
testb $0x1, %al
jne 0x5745a
jmp 0x5749c
leaq -0x18(%rbp), %rdi
callq 0x51c10
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
je 0x5748f
movq -0x78(%rbp), %rdi
callq 0x3a5c0
movq -0x78(%rbp), %rdi
movl $0x48, %esi
callq 0x84f0
jmp 0x57491
leaq -0x18(%rbp), %rdi
callq 0x51c30
jmp 0x57447
movq -0x70(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3a140
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x39fd0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x51e40
testb $0x1, %al
jne 0x574d5
jmp 0x57517
leaq -0x38(%rbp), %rdi
callq 0x51e80
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x5750a
movq -0x80(%rbp), %rdi
callq 0xb1a20
movq -0x80(%rbp), %rdi
movl $0x40, %esi
callq 0x84f0
jmp 0x5750c
leaq -0x38(%rbp), %rdi
callq 0x51ea0
jmp 0x574c2
movq -0x70(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x3a140
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x39fd0
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x51e40
testb $0x1, %al
jne 0x57550
jmp 0x5759b
leaq -0x58(%rbp), %rdi
callq 0x51e80
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, %rax
je 0x5758e
movq -0x88(%rbp), %rdi
callq 0xb1a20
movq -0x88(%rbp), %rdi
movl $0x40, %esi
callq 0x84f0
jmp 0x57590
leaq -0x58(%rbp), %rdi
callq 0x51ea0
jmp 0x5753d
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
callq 0x577d0
movq -0x70(%rbp), %rdi
addq $0x30, %rdi
callq 0x577f0
movq -0x70(%rbp), %rdi
addq $0x70, %rdi
callq 0x8330
movq -0x70(%rbp), %rdi
addq $0x48, %rdi
callq 0xdd90
movq -0x70(%rbp), %rdi
addq $0x30, %rdi
callq 0xdd90
movq -0x70(%rbp), %rdi
addq $0x18, %rdi
callq 0xddf0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Kei18[P]pibt/./src/solver/cbs.cpp
// Function: CBS::calcCost(CTNode*, std::vector<Agent*, std::allocator<Agent*>>&)
void CBS::calcCost(CTNode* node, Agents& block) {
  int cost = 0;
  Node* g;
  Nodes path;
  for (auto a : block) {
    auto itr1 = std::find_if(A.begin(), A.end(),
                            [a](Agent* b) { return a == b; });
    g = a->getGoal();
    path = node->paths[std::distance(A.begin(), itr1)];
    auto itr2 = path.end() - 1;
    while (g == *itr2) --itr2;
    cost += std::distance(path.begin(), itr2);
  }
  node->cost = cost;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3e880
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x39b60
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x399f0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x51bd0
testb $0x1, %al
jne 0x5a82a
jmp 0x5a9ef
leaq -0x50(%rbp), %rdi
callq 0x51c10
movq -0xc8(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x60(%rbp)
addq $0x20, %rdi
movq %rdi, -0xd8(%rbp)
callq 0x39b60
movq -0xd8(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x399f0
movq %rax, -0x78(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x80(%rbp), %rdx
callq 0x5abb0
movq %rax, -0xd0(%rbp)
jmp 0x5a887
movq -0xd0(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0x56820
movq %rax, -0xe0(%rbp)
jmp 0x5a8a4
movq -0xc8(%rbp), %rdi
movq -0xe0(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0xf0(%rbp)
addq $0x20, %rdi
callq 0x39b60
movq %rax, -0x98(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x62750
movq %rax, -0xe8(%rbp)
jmp 0x5a8fc
movq -0xe8(%rbp), %rsi
movq -0xf0(%rbp), %rdi
callq 0xda70
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x3eca0
jmp 0x5a91d
leaq -0x40(%rbp), %rdi
callq 0x3b760
movq %rax, -0xb0(%rbp)
leaq -0xb0(%rbp), %rdi
movl $0x1, %esi
callq 0x4c520
movq %rax, -0xa8(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xf8(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x3bb00
movq %rax, %rcx
movq -0xf8(%rbp), %rax
cmpq (%rcx), %rax
jne 0x5a996
leaq -0xa8(%rbp), %rdi
callq 0x468c0
jmp 0x5a945
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xd7d0
jmp 0x5aa0b
leaq -0x40(%rbp), %rdi
callq 0x3b730
movq %rax, -0xb8(%rbp)
movq -0xa8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0xb8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x63310
movq %rax, -0x100(%rbp)
jmp 0x5a9d0
movq -0x100(%rbp), %rcx
movslq -0x1c(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x51c30
jmp 0x5a814
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
leaq -0x40(%rbp), %rdi
callq 0xd7d0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x8880
nopw (%rax,%rax)
// File: Kei18[P]pibt/./src/solver/cbs.cpp
// Function: CBS::formalizePathAgents(CTNode*, std::vector<Agent*, std::allocator<Agent*>>&)
void CBS::formalizePathAgents(CTNode* node, Agents& block) {
  int maxLength = getMaxLengthPaths(node->paths);
  Node* g;
  int i;
  for (auto a : block) {
    auto itr = std::find_if(A.begin(), A.end(),
                            [a](Agent* b) { return a == b; });
    i = std::distance(A.begin(), itr);
    g = node->paths[i][node->paths[i].size() - 1];
    while (node->paths[i].size() != maxLength) node->paths[i].push_back(g);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x9d280
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x39b60
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x399f0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x51bd0
testb $0x1, %al
jne 0x5aa8a
jmp 0x5aba7
leaq -0x40(%rbp), %rdi
callq 0x51c10
movq -0x88(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x50(%rbp)
addq $0x20, %rdi
callq 0x39b60
movq -0x88(%rbp), %rdi
movq %rax, -0x60(%rbp)
addq $0x20, %rdi
callq 0x399f0
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x5b130
movq -0x88(%rbp), %rdi
movq %rax, -0x58(%rbp)
addq $0x20, %rdi
callq 0x39b60
movq %rax, -0x78(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x62750
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movslq -0x2c(%rbp), %rsi
callq 0xda70
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movslq -0x2c(%rbp), %rsi
callq 0xda70
movq %rax, %rdi
callq 0x3b0e0
movq -0x90(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0xda90
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movslq -0x2c(%rbp), %rsi
callq 0xda70
movq %rax, %rdi
callq 0x3b0e0
movslq -0x1c(%rbp), %rcx
cmpq %rcx, %rax
je 0x5ab97
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
movslq -0x2c(%rbp), %rsi
callq 0xda70
movq %rax, %rdi
leaq -0x28(%rbp), %rsi
callq 0x3f490
jmp 0x5ab56
jmp 0x5ab99
leaq -0x40(%rbp), %rdi
callq 0x51c30
jmp 0x5aa74
addq $0x90, %rsp
popq %rbp
retq
// File: Kei18[P]pibt/./src/solver/cbs.cpp
// Function: CBS::getConstraints(CTNode*)
Constraint CBS::getConstraints(CTNode* ctNode) {
  Constraint constraints = {};
  CTNode* p = ctNode;
  while (p != nullptr) {
    for (auto c : p->c) constraints.push_back(c);
    p = p->p;
  }
  return constraints;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x82c0
movq -0x60(%rbp), %rdi
callq 0x62930
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5b104
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x63230
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x63260
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x63290
testb $0x1, %al
jne 0x5b0b0
jmp 0x5b0f3
leaq -0x38(%rbp), %rdi
callq 0x632d0
movq -0x60(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x633b0
jmp 0x5b0cf
jmp 0x5b0d1
leaq -0x38(%rbp), %rdi
callq 0x632f0
jmp 0x5b09d
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x62ea0
jmp 0x5b121
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x5b070
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x5b117
movq -0x60(%rbp), %rdi
callq 0x62ea0
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x8880
nopw (%rax,%rax)
// File: Kei18[P]pibt/./src/solver/cbs.cpp
// Function: CBS::getConstraintsForAgent(CTNode*, Agent*)
Constraint CBS::getConstraintsForAgent(CTNode* ctNode, Agent* a) {
  Constraint constraints = {};
  CTNode* p = ctNode;
  while (p != nullptr) {
    for (auto c : p->c) {
      if (c->a == a) constraints.push_back(c);
    }
    p = p->p;
  }
  return constraints;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x82c0
movq -0x68(%rbp), %rdi
callq 0x62930
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x5c437
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x63230
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x63260
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x63290
testb $0x1, %al
jne 0x5c3d4
jmp 0x5c426
leaq -0x40(%rbp), %rdi
callq 0x632d0
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x5c419
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x633b0
jmp 0x5c400
jmp 0x5c419
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x62ea0
jmp 0x5c454
jmp 0x5c41b
leaq -0x40(%rbp), %rdi
callq 0x632f0
jmp 0x5c3c1
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x5c394
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x5c44a
movq -0x68(%rbp), %rdi
callq 0x62ea0
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x8880
nopl (%rax)
// File: Kei18[P]pibt/./src/solver/cbs.cpp
// Function: CBS::getCKey[abi:cxx11](Node*, Node*, std::vector<Conflict*, std::allocator<Conflict*>>&)
std::string CBS::getCKey(Node* s, Node* g, Constraint &constraints) {
  std::string key = std::to_string(s->getId()) + "-" + std::to_string(g->getId());
  for (auto c : constraints) {
    key += "-" + c->key;
  }
  return key;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3ae00
movl %eax, %esi
leaq -0x70(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0xdf50
movq -0xe8(%rbp), %rsi
leaq 0x5b436(%rip), %rdx     # 0xb78f3
leaq -0x50(%rbp), %rdi
callq 0xdeb0
jmp 0x5c4c8
movq -0x20(%rbp), %rdi
callq 0x3ae00
movl %eax, -0xfc(%rbp)
jmp 0x5c4d9
movl -0xfc(%rbp), %esi
leaq -0xa0(%rbp), %rdi
callq 0xdf50
jmp 0x5c4ed
movq -0xf8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x63a80
jmp 0x5c506
leaq -0xa0(%rbp), %rdi
callq 0x8330
leaq -0x50(%rbp), %rdi
callq 0x8330
leaq -0x70(%rbp), %rdi
callq 0x8330
movq -0x28(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
callq 0x63230
movq %rax, -0xb0(%rbp)
movq -0xa8(%rbp), %rdi
callq 0x63260
movq %rax, -0xb8(%rbp)
leaq -0xb0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x63290
testb $0x1, %al
jne 0x5c571
jmp 0x5c649
leaq -0xb0(%rbp), %rdi
callq 0x632d0
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rdx
addq $0x28, %rdx
leaq 0x5b35a(%rip), %rsi     # 0xb78f3
leaq -0xe0(%rbp), %rdi
callq 0xe070
jmp 0x5c5a7
movq -0xf8(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x8640
jmp 0x5c5bc
leaq -0xe0(%rbp), %rdi
callq 0x8330
leaq -0xb0(%rbp), %rdi
callq 0x632f0
jmp 0x5c555
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x5c616
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x5c60d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x8330
leaq -0x50(%rbp), %rdi
callq 0x8330
leaq -0x70(%rbp), %rdi
callq 0x8330
jmp 0x5c67b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x5c66f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x8330
jmp 0x5c66f
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x5c65f
movq -0xf8(%rbp), %rdi
callq 0x8330
movq -0xf0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xf8(%rbp), %rdi
callq 0x8330
movq -0x78(%rbp), %rdi
callq 0x8880
nopw %cs:(%rax,%rax)
// File: Kei18[P]pibt/./src/solver/cbs.cpp
// Function: CBS::validShorcut(Agent*, AN*, Node*, std::vector<Conflict*, std::allocator<Conflict*>>&, std::vector<Node*, std::allocator<Node*>>&)
bool CBS::validShorcut(Agent* a, AN* n, Node* _g,
                       Constraint &constraints,
                       Nodes &tmpPath) {
  auto itrC = std::find_if(constraints.begin(), constraints.end(),
                           [a, n, _g, &tmpPath] (Conflict* c) {
                             if (c->a != a) return false;
                             if (c->t < n->g) return false;
                             if (c->onNode) {
                               if (c->t > tmpPath.size() + n->g - 1) {
                                 if (c->v == _g) return true;
                               } else {
                                 if (c->v == tmpPath[c->t - n->g]) return true;
                               }
                             } else {
                               if (c->t <= 0
                                   || c->t > tmpPath.size() + n->g) return false;
                               if (c->v == tmpPath[c->t - n->g]
                                   && c->u == tmpPath[c->t - n->g - 1])
                                 return true;
                             }
                             return false;
                           });
  return itrC == constraints.end();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x63230
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x63260
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x5ccb0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x63260
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x63a40
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: Kei18[P]pibt/./src/solver/cbs.cpp
// Function: CBS::isDuplicatedConflict(std::vector<Conflict*, std::allocator<Conflict*>>&, Conflict*)
bool CBS::isDuplicatedConflict(Constraint &constraint, Conflict* c) {
  auto itr = std::find_if(constraint.begin(), constraint.end(),
                          [c] (Conflict* d)
                          { if (c->onNode != d->onNode) return false;
                            if (c->a != d->a) return false;
                            if (c->onNode && d->onNode) {
                              return c->t == d->t && c->v == d->v;
                            }
                            return c->t == d->t
                                && c->v == d->v
                                && c->u == d->u;
                          });
  return itr != constraint.end();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x63230
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x63260
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x5c880
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x63260
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x63290
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Kei18[P]pibt/./src/solver/cbs.cpp
// Function: CBS::isDuplicatedConflict(Conflict*, Conflict*)
bool CBS::isDuplicatedConflict(Conflict* c1, Conflict* c2) {
  if (c1->a != c2->a) return false;
  if (c1->t != c2->t) return false;
  if (c1->v != c2->v) return false;
  if (c1->onNode != c2->onNode) return false;
  if (!c1->onNode && c1->u != c2->u) return false;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
je 0x5c906
movb $0x0, -0x1(%rbp)
jmp 0x5c97d
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x5c91c
movb $0x0, -0x1(%rbp)
jmp 0x5c97d
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
je 0x5c934
movb $0x0, -0x1(%rbp)
jmp 0x5c97d
movq -0x18(%rbp), %rax
movb 0x20(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movq -0x20(%rbp), %rcx
movb 0x20(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x5c957
movb $0x0, -0x1(%rbp)
jmp 0x5c97d
movq -0x18(%rbp), %rax
testb $0x1, 0x20(%rax)
jne 0x5c979
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x18(%rcx), %rax
je 0x5c979
movb $0x0, -0x1(%rbp)
jmp 0x5c97d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Kei18[P]pibt/./src/solver/cbs.cpp
// Function: CBS::logStr[abi:cxx11]()
std::string CBS::logStr() {
  std::string str;
  str += "[solver] type:CBS\n";
  str += "[solver] ID:" + std::to_string(ID) + "\n";
  str += Solver::logStr();
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x86b0
movq -0xb0(%rbp), %rdi
leaq 0x58a7d(%rip), %rsi     # 0xb5833
callq 0x84c0
jmp 0x5cdbd
movq -0xb8(%rbp), %rax
movzbl 0x68(%rax), %esi
andl $0x1, %esi
leaq -0x88(%rbp), %rdi
callq 0xdf50
jmp 0x5cdd9
leaq 0x58a66(%rip), %rsi     # 0xb5846
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0xdf00
jmp 0x5cdf2
leaq 0x567be(%rip), %rdx     # 0xb35b7
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xdeb0
jmp 0x5ce08
movq -0xb0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8640
jmp 0x5ce1a
leaq -0x48(%rbp), %rdi
callq 0x8330
leaq -0x68(%rbp), %rdi
callq 0x8330
leaq -0x88(%rbp), %rdi
callq 0x8330
movq -0xb8(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x9da50
jmp 0x5ce4d
movq -0xb0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x8640
jmp 0x5ce62
leaq -0xa8(%rbp), %rdi
callq 0x8330
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x5cef6
jmp 0x5ceea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x5cf06
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x5cec2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x5ceb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8330
leaq -0x68(%rbp), %rdi
callq 0x8330
leaq -0x88(%rbp), %rdi
callq 0x8330
jmp 0x5cf06
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x8330
jmp 0x5cf06
movq -0xb0(%rbp), %rdi
callq 0x8330
movq -0xc0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x8330
movq -0x20(%rbp), %rdi
callq 0x8880
nopl (%rax,%rax)
// File: Kei18[P]pibt/./src/solver/ecbs.cpp
// Function: ECBS::getPartialPath(AN*, std::vector<Node*, std::allocator<Node*>>&)
void ECBS::getPartialPath(AN* n, Nodes &path) {
  path.clear();
  AN* m = n;
  while (m != nullptr) {
    path.push_back(m->v);
    m = m->p;
  }
  std::reverse(path.begin(), path.end());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3e9f0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x729f7
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3f490
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x729d5
movq -0x18(%rbp), %rdi
callq 0x3b730
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3b760
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3f500
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Kei18[P]pibt/./src/solver/ecbs.cpp
// Function: ECBS::logStr[abi:cxx11]()
std::string ECBS::logStr() {
  std::string str;
  str += "[solver] type:ECBS\n";
  str += "[solver] w:" + std::to_string(w) + "\n";
  str += "[solver] ID:" + std::to_string(ID) + "\n";
  str += Solver::logStr();
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x110(%rbp)
movq %rdi, %rax
movq %rax, -0x120(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x118(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x86b0
movq -0x110(%rbp), %rdi
leaq 0x42ef9(%rip), %rsi     # 0xb596f
callq 0x84c0
jmp 0x72a7d
movq -0x118(%rbp), %rax
movss 0xa8(%rax), %xmm0
leaq -0x88(%rbp), %rdi
callq 0x555e0
jmp 0x72a9a
leaq 0x42ee2(%rip), %rsi     # 0xb5983
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0xdf00
jmp 0x72ab3
leaq 0x40afd(%rip), %rdx     # 0xb35b7
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xdeb0
jmp 0x72ac9
movq -0x110(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8640
jmp 0x72adb
leaq -0x48(%rbp), %rdi
callq 0x8330
leaq -0x68(%rbp), %rdi
callq 0x8330
leaq -0x88(%rbp), %rdi
callq 0x8330
movq -0x118(%rbp), %rax
movzbl 0x68(%rax), %esi
andl $0x1, %esi
leaq -0xe8(%rbp), %rdi
callq 0xdf50
jmp 0x72b15
leaq 0x42d2a(%rip), %rsi     # 0xb5846
leaq -0xc8(%rbp), %rdi
leaq -0xe8(%rbp), %rdx
callq 0xdf00
jmp 0x72b31
leaq 0x40a7f(%rip), %rdx     # 0xb35b7
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0xdeb0
jmp 0x72b4d
movq -0x110(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x8640
jmp 0x72b62
leaq -0xa8(%rbp), %rdi
callq 0x8330
leaq -0xc8(%rbp), %rdi
callq 0x8330
leaq -0xe8(%rbp), %rdi
callq 0x8330
movq -0x118(%rbp), %rsi
leaq -0x108(%rbp), %rdi
callq 0x9da50
jmp 0x72b9b
movq -0x110(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x8640
jmp 0x72bb0
leaq -0x108(%rbp), %rdi
callq 0x8330
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x72c9f
jmp 0x72c93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x72caf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x72c1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x72c11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8330
leaq -0x68(%rbp), %rdi
callq 0x8330
leaq -0x88(%rbp), %rdi
callq 0x8330
jmp 0x72caf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x72c6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x72c5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x8330
leaq -0xc8(%rbp), %rdi
callq 0x8330
leaq -0xe8(%rbp), %rdi
callq 0x8330
jmp 0x72caf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x8330
jmp 0x72caf
movq -0x110(%rbp), %rdi
callq 0x8330
movq -0x120(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x110(%rbp), %rdi
callq 0x8330
movq -0x20(%rbp), %rdi
callq 0x8880
nopw %cs:(%rax,%rax)
// File: Kei18[P]pibt/./src/solver/ecbs.cpp
// Function: Fib_FN::operator<(Fib_FN const&) const
bool operator<(const Fib_FN& other) const {
    if (h != other.h) {
      return h > other.h;
    } else {
      if (node->f != other.node->f) {
        return node->f > other.node->f;
      } else {
        return node->g < other.node->g;
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x7b3d8
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x7b428
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0xc(%rax), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0xc(%rcx), %eax
je 0x7b40c
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0xc(%rax), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0xc(%rcx), %eax
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x7b428
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: Kei18[P]pibt/./src/solver/iecbs.cpp
// Function: Fib_FN_iECBS::operator<(Fib_FN_iECBS const&) const
bool operator<(const Fib_FN_iECBS & other) const {
    if (h != other.h) {
      return h > other.h;
    } else {  // h == other.h
      float cThis  = highway + (float)node->g;
      float cOther = other.highway + (float)other.node->g;
      if (cThis != cOther) {
        return cThis > cOther;
      } else {
        return node->g < other.node->g;
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x85468
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x854de
movq -0x28(%rbp), %rax
movss 0xc(%rax), %xmm0
movq (%rax), %rax
cvtsi2ssl 0x8(%rax), %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm0
movq -0x18(%rbp), %rax
movq (%rax), %rax
cvtsi2ssl 0x8(%rax), %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x1c(%rbp), %xmm0
ucomiss -0x20(%rbp), %xmm0
jne 0x854af
jp 0x854af
jmp 0x854c2
movss -0x1c(%rbp), %xmm0
ucomiss -0x20(%rbp), %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x854de
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Kei18[P]pibt/./src/solver/iecbs.cpp
// Function: Fib_ANF::operator<(Fib_ANF const&) const
bool operator<(const Fib_ANF& other) const {
    if (node->f != other.node->f) {
      return node->f > other.node->f;
    } else {
      return node->g < other.node->g;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rax
movss 0xc(%rax), %xmm0
movq -0x18(%rbp), %rax
movq (%rax), %rax
ucomiss 0xc(%rax), %xmm0
jne 0x8770d
jp 0x8770d
jmp 0x8772e
movq -0x20(%rbp), %rax
movq (%rax), %rax
movss 0xc(%rax), %xmm0
movq -0x18(%rbp), %rax
movq (%rax), %rax
ucomiss 0xc(%rax), %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x87751
movq -0x20(%rbp), %rax
movq (%rax), %rax
movss 0x8(%rax), %xmm1
movq -0x18(%rbp), %rax
movq (%rax), %rax
movss 0x8(%rax), %xmm0
ucomiss %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: Kei18[P]pibt/./src/solver/pibt.cpp
// Function: PIBT::init()
void PIBT::init() {
  G->setRegFlg(true);

  // initialize priroirty
  int agentNum = A.size();
  for (int i = 0; i < agentNum ; ++i) {
    epsilon.push_back((float)i / agentNum);
    eta.push_back(0);
    priority.push_back(epsilon[i] + eta[i]);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x38(%rax), %rdi
movl $0x1, %esi
callq 0x62120
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x383b0
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x8928c
movq -0x28(%rbp), %rdi
addq $0x68, %rdi
cvtsi2ssl -0x10(%rbp), %xmm0
cvtsi2ssl -0xc(%rbp), %xmm1
divss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x8bac0
movq -0x28(%rbp), %rdi
addq $0x80, %rdi
movl $0x0, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x536f0
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x98, %rax
movq %rax, -0x30(%rbp)
addq $0x68, %rdi
movslq -0x10(%rbp), %rsi
callq 0x8baf0
movq -0x28(%rbp), %rdi
movss (%rax), %xmm0
movss %xmm0, -0x34(%rbp)
addq $0x80, %rdi
movslq -0x10(%rbp), %rsi
callq 0x4ea00
movss -0x34(%rbp), %xmm0
movq -0x30(%rbp), %rdi
cvtsi2ssl (%rax), %xmm1
addss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x8bac0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x891d9
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Kei18[P]pibt/./src/solver/pibt.cpp
// Function: PIBT::solve()
bool PIBT::solve() {
  solveStart();

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

  solveEnd();
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq (%rdi), %rax
callq *(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
xorb $-0x1, %al
testb $0x1, %al
jne 0x893ef
jmp 0x8943c
movq -0x10(%rbp), %rdi
callq 0x89450
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x622f0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, -0x14(%rbp)
movq 0x10(%rax), %rdi
callq 0x62310
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jl 0x8943a
jmp 0x8943c
jmp 0x893d9
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq