// File: /workspace/github_cpp_makefile_star2_O2/Kei18[P]pibt/./src/solver/ecbs.cpp
// Function: ECBS::AstarSearch(Agent*, CTNode*)
Nodes ECBS::AstarSearch(Agent* a, CTNode* node) {
  Constraint constraints = getConstraintsForAgent(node, a);

  Node* _s = a->getNode();
  Node* _g = a->getGoal();

  Nodes path, tmpPath, C;  // return

  // ==== fast implementation ====
  // constraint free
  if (constraints.empty()) {
    path = G->getPath(_s, _g);
    table_fmin.at(a->getId()) = path.size() - 1;
    return path;
  }

  // goal condition
  bool existGoalConstraint = false;
  int timeGoalConstraint = 0;
  for (auto c: constraints) {
    if (c->onNode && c->v == _g && c->t > timeGoalConstraint) {
      existGoalConstraint = true;
      timeGoalConstraint = c->t;
    }
  }
  // =============================

  auto paths = node->paths;

  int f, g;
  float ub;
  int ubori;
  std::string key, keyM, keyF;
  bool invalid = true;

  boost::heap::fibonacci_heap<Fib_AN> OPEN;
  std::unordered_map<std::string, boost::heap::fibonacci_heap<Fib_AN>::handle_type> SEARCHED;
  std::unordered_set<std::string> CLOSE;  // key
  AN* n = new AN { _s, 0, pathDist(_s, _g), nullptr };
  auto handle = OPEN.push(Fib_AN(n));
  key = getKey(n);
  SEARCHED.emplace(key, handle);

  bool updateMin = true;
  std::unordered_map<std::string, int> table_conflict;
  table_conflict.emplace(key, 0);
  // FOCUL
  boost::heap::fibonacci_heap<Fib_FN> FOCUL;
  std::unordered_map<std::string,
                     boost::heap::fibonacci_heap<Fib_FN>::handle_type> SEARCHED_F;

  while (!OPEN.empty()) {
    if (updateMin || FOCUL.empty()) {
      // argmin
      while (!OPEN.empty()
             && CLOSE.find(getKey(OPEN.top().node)) != CLOSE.end()) OPEN.pop();
      if (OPEN.empty()) break;
      n = OPEN.top().node;
      ubori = n->f;
      keyM = getKey(n);
      ub = n->f * w;
      // update focul
      FOCUL.clear();
      SEARCHED_F.clear();
      for (auto itr = OPEN.ordered_begin(); itr != OPEN.ordered_end(); ++itr) {
        AN* l = (*itr).node;
        if ((float)l->f <= ub) {
          if (CLOSE.find(getKey(l)) == CLOSE.end()) {
            key = getKey(l);
            auto handle_f = FOCUL.push(Fib_FN(l, table_conflict.at(key)));
            SEARCHED_F.emplace(key, handle_f);
          }
        } else {
          break;
        }
      }
    }

    // argmin in FOCUL
    n = FOCUL.top().node;
    key = getKey(n);
    FOCUL.pop();

    // already explored
    if (CLOSE.find(key) != CLOSE.end()) continue;

    // check goal
    if (n->v == _g) {
      if (!existGoalConstraint || timeGoalConstraint < n->g) {
        invalid = false;
        break;
      }
    }

    // update list
    updateMin = (key == keyM);
    CLOSE.emplace(key);

    // search neighbor
    C = G->neighbor(n->v);
    C.push_back(n->v);

    for (auto m : C) {
      g = n->g + 1;
      key = getKey(g, m);
      if (CLOSE.find(key) != CLOSE.end()) continue;

      // check constraints
      auto constraint = std::find_if(constraints.begin(), constraints.end(),
                                     [a, g, m, n] (Conflict* c) {
                                       if (c->a != a) return false;
                                       if (c->t != g) return false;
                                       if (c->onNode) return c->v == m;
                                       return c->v == m && c->u == n->v;
                                     });
      if (constraint != constraints.end()) continue;
      f = g + pathDist(m, _g);

      // ==== fast implementation ====
      // when field is huge, this works well
      // if (existGoalConstraint) {
      //   f = pathDist(m, _g) + timeGoalConstraint;
      // }
      // =============================

      auto itrS = SEARCHED.find(key);
      AN* l;
      bool updateH = false;
      if (itrS == SEARCHED.end()) {  // new node
        l = new AN { m, g, f, n };
        auto handle = OPEN.push(Fib_AN(l));
        SEARCHED.emplace(key, handle);
        getPartialPath(l, tmpPath);
        table_conflict.emplace(key, h3(a, tmpPath, paths));
      } else {
        auto handle = itrS->second;
        l = (*handle).node;
        if (l->f > f) {
          l->g = g;
          l->f = f;
          l->p = n;
          getPartialPath(l, tmpPath);
          table_conflict.at(key) = h3(a, tmpPath, paths);
          OPEN.increase(handle);
          updateH = true;
        }
      }

      tmpPath.clear();
      if (f <= ub) {
        auto itrSF = SEARCHED_F.find(key);
        if (itrSF == SEARCHED_F.end()) {
          auto handle_f = FOCUL.push(Fib_FN(l, table_conflict.at(key)));
          SEARCHED_F.emplace(key, handle_f);
        } else {
          if (updateH) {
            auto handle_f = itrSF->second;
            (*handle_f).h = table_conflict.at(key);
            FOCUL.increase(handle_f);
          }
        }
      }
    }
  }

  // back tracking
  int fmin = 0;
  if (!invalid) {  // check failed or not
    getPartialPath(n, path);
    fmin = ubori;
  } else {
    node->valid = false;
  }
  table_fmin.at(a->getId()) = fmin;

  return path;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2d8, %rsp            # imm = 0x2D8
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %r12
leaq 0x1d8(%rsp), %r14
movq %r14, %rdi
movq %rcx, 0x98(%rsp)
movq %rcx, %rdx
movq %r15, %rcx
callq 0x21686
movq 0x8(%r15), %rbx
movq %r15, 0x28(%rsp)
movq 0x10(%r15), %rcx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%r12)
movq %r12, 0x18(%rsp)
movups %xmm0, (%r12)
andq $0x0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
andq $0x0, 0x130(%rsp)
movaps %xmm0, 0x120(%rsp)
movq (%r14), %rax
movq 0x8(%r14), %rdi
cmpq %rdi, %rax
je 0x267a4
movq %rcx, 0x40(%rsp)
movl $0x0, 0x20(%rsp)
movl $0x0, 0x24(%rsp)
cmpq %rdi, %rax
je 0x25df2
movq (%rax), %rdx
cmpb $0x1, 0x20(%rdx)
jne 0x25dec
movq 0x40(%rsp), %rcx
cmpq %rcx, 0x10(%rdx)
jne 0x25dec
movl 0x8(%rdx), %edx
movl 0x20(%rsp), %ecx
cmpl %ecx, %edx
setg %sil
cmovgl %edx, %ecx
movl %ecx, 0x20(%rsp)
movl 0x24(%rsp), %ecx
orb %sil, %cl
movl %ecx, 0x24(%rsp)
addq $0x8, %rax
jmp 0x25db4
movq 0x98(%rsp), %rax
leaq 0x18(%rax), %rsi
leaq 0x1c0(%rsp), %rdi
callq 0x227f6
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x238(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq 0x2c8(%rsp), %rdx
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
movb %cl, (%rax)
movb %cl, (%rdx)
leaq 0xb8(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rax)
andq $0x0, -0x8(%rax)
movq %rax, (%rax)
movq %rax, 0x8(%rax)
leaq 0x220(%rsp), %rax
movq %rax, -0x30(%rax)
pushq $0x1
popq %rcx
movq %rcx, -0x28(%rax)
movups %xmm0, -0x20(%rax)
movl $0x3f800000, %edx       # imm = 0x3F800000
movl %edx, -0x10(%rax)
movups %xmm0, -0x8(%rax)
leaq 0x2b0(%rsp), %rax
movq %rax, -0x30(%rax)
movq %rcx, -0x28(%rax)
movups %xmm0, -0x20(%rax)
movl %edx, -0x10(%rax)
movups %xmm0, -0x8(%rax)
pushq $0x18
popq %rdi
callq 0x63b0
movq %rax, %r14
movq %rbx, (%rax)
andl $0x0, 0x8(%rax)
movq %rbp, %rdi
movq %rbx, %rsi
movq 0x40(%rsp), %rdx
callq 0x32cd4
movl %eax, 0xc(%r14)
andq $0x0, 0x10(%r14)
leaq 0x188(%rsp), %rsi
movq %r14, (%rsi)
leaq 0xa0(%rsp), %rdi
callq 0x1705a
movq %rax, 0x180(%rsp)
leaq 0x188(%rsp), %rdi
movq %r14, %rsi
callq 0x32fe8
leaq 0x48(%rsp), %rbx
leaq 0x188(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6470
movq %r14, %rdi
callq 0x61d0
leaq 0x1f0(%rsp), %rdi
leaq 0x180(%rsp), %rdx
movq %rbx, %rsi
callq 0x23fea
leaq 0x1b8(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
leaq 0x248(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x188(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x276d6
leaq 0x158(%rsp), %rax
andq $0x0, -0x8(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, -0x18(%rax)
movq %rax, (%rax)
movq %rax, 0x8(%rax)
leaq 0x278(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movb $0x1, 0x7(%rsp)
leaq 0xa0(%rsp), %r15
leaq 0xf8(%rsp), %rbx
cmpq $0x0, 0xa0(%rsp)
je 0x266f3
cmpq $0x0, 0x140(%rsp)
sete %al
orb 0x7(%rsp), %al
testb $0x1, %al
je 0x261e8
cmpq $0x0, 0xa0(%rsp)
je 0x266f3
movq %r15, %rdi
callq 0x170d2
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x32fe8
leaq 0x280(%rsp), %rdi
movq %rbx, %rsi
callq 0x2477c
movq %rax, %r14
movq %rbx, %rdi
callq 0x61d0
testq %r14, %r14
je 0x26038
movq %r15, %rdi
callq 0x17102
jmp 0x25fec
cmpq $0x0, 0xa0(%rsp)
je 0x266f3
movq %r15, %rdi
callq 0x170d2
movq (%rax), %r14
movl 0xc(%r14), %eax
movl %eax, 0x6c(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32fe8
leaq 0x228(%rsp), %rdi
movq %rbx, %rsi
callq 0x6470
movq %rbx, %rdi
callq 0x61d0
cvtsi2ssl 0xc(%r14), %xmm0
mulss 0xa8(%rbp), %xmm0
movss %xmm0, 0x34(%rsp)
leaq 0x140(%rsp), %rdi
callq 0x26ce2
leaq 0x248(%rsp), %rdi
callq 0x26fe2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x26cfa
leaq 0xd0(%rsp), %rdi
movq %r15, %rsi
callq 0x26d2e
movq 0xf8(%rsp), %r14
movq 0xd0(%rsp), %r15
leaq 0xd8(%rsp), %rdi
callq 0x26f92
cmpq %r15, %r14
je 0x261d3
movq 0xf8(%rsp), %rax
movq 0x10(%rax), %r14
cvtsi2ssl 0xc(%r14), %xmm0
movss 0x34(%rsp), %xmm1
ucomiss %xmm0, %xmm1
jb 0x261d3
leaq 0xd0(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x32fe8
leaq 0x280(%rsp), %rdi
movq %r12, %rsi
callq 0x2477c
movq %rax, %r15
movq %r12, %rdi
callq 0x61d0
testq %r15, %r15
leaq 0xa0(%rsp), %r15
jne 0x261c6
leaq 0xd0(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x32fe8
leaq 0x48(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x6470
movq %r12, %rdi
callq 0x61d0
leaq 0x188(%rsp), %rdi
movq %r13, %rsi
callq 0x28156
movl (%rax), %eax
movq %r14, 0xd0(%rsp)
movl %eax, 0xd8(%rsp)
leaq 0x140(%rsp), %rdi
movq %r12, %rsi
callq 0x26d44
movq %rax, 0x178(%rsp)
leaq 0x248(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x178(%rsp), %rdx
callq 0x281a2
movq %rbx, %rdi
callq 0x280a2
jmp 0x260b6
leaq 0x100(%rsp), %rdi
callq 0x26f92
leaq 0xa0(%rsp), %r15
leaq 0x140(%rsp), %rdi
callq 0x26dc4
movq (%rax), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x32fe8
leaq 0x48(%rsp), %rdi
movq %rbx, %rsi
callq 0x6470
movq %rbx, %rdi
callq 0x61d0
leaq 0x140(%rsp), %rdi
callq 0x26df4
leaq 0x280(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2477c
testq %rax, %rax
jne 0x25fc5
movq 0x40(%rsp), %rax
cmpq %rax, (%r12)
jne 0x26265
testb $0x1, 0x24(%rsp)
je 0x2684b
movl 0x20(%rsp), %eax
cmpl 0x8(%r12), %eax
jl 0x2684b
leaq 0x48(%rsp), %r14
movq %r14, %rdi
leaq 0x228(%rsp), %rsi
callq 0xe5b7
movb %al, 0x7(%rsp)
leaq 0x280(%rsp), %rdi
movq %r14, %rsi
callq 0x28822
movq 0x38(%rbp), %rsi
movq (%r12), %rdx
movq %rbx, %rdi
callq 0x164ca
leaq 0x120(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18466
movq %rbx, %rdi
callq 0x990e
movq %r14, %rdi
movq %r12, %rsi
callq 0x171da
movq 0x120(%rsp), %rax
movq 0x128(%rsp), %rcx
movq %rcx, 0x168(%rsp)
movq %rbp, 0x38(%rsp)
movq %r12, 0x90(%rsp)
cmpq 0x168(%rsp), %rax
je 0x25fc5
movq %rax, 0x170(%rsp)
movq (%rax), %rbp
movl 0x8(%r12), %r13d
incl %r13d
movq %rbx, %rdi
movl %r13d, %esi
movq %rbp, %rdx
callq 0x32f4c
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6470
movq %rbx, %rdi
callq 0x61d0
leaq 0x280(%rsp), %rdi
movq %r14, %rsi
callq 0x2477c
testq %rax, %rax
jne 0x2668f
movq %r12, %rcx
movq 0x1d8(%rsp), %r12
movq 0x1e0(%rsp), %r14
movq 0x28(%rsp), %rax
movq %rax, 0xf8(%rsp)
movl %r13d, 0x100(%rsp)
movq %rbp, 0x8(%rsp)
movq %rbp, 0x108(%rsp)
movq %rcx, 0x110(%rsp)
movq %r14, 0x10(%rsp)
subq %r12, %r14
movq %r14, %rbp
sarq $0x5, %rbp
testq %rbp, %rbp
jle 0x263fe
movq %rbx, %rdi
movq %r12, %rsi
callq 0x26bd4
testb %al, %al
jne 0x2643d
leaq 0x8(%r12), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x26bd4
testb %al, %al
jne 0x26440
leaq 0x10(%r12), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x26bd4
testb %al, %al
jne 0x26440
leaq 0x18(%r12), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x26bd4
testb %al, %al
jne 0x26440
addq $0x20, %r12
decq %rbp
addq $-0x20, %r14
leaq 0xa0(%rsp), %r15
jmp 0x26395
sarq $0x3, %r14
cmpq $0x1, %r14
je 0x266a5
cmpq $0x2, %r14
movq 0x8(%rsp), %rbp
je 0x266c2
cmpq $0x3, %r14
jne 0x266b1
movq %rbx, %rdi
movq %r12, %rsi
callq 0x26bd4
testb %al, %al
je 0x266be
movq %r12, %r15
jmp 0x26445
movq %r12, %r15
movq 0x8(%rsp), %rbp
movq 0x10(%rsp), %r14
cmpq %r14, %r15
leaq 0xa0(%rsp), %r15
movq 0x90(%rsp), %r12
jne 0x2668f
movq 0x38(%rsp), %rdi
movq %rbp, %rsi
movq 0x40(%rsp), %rdx
callq 0x32cd4
movl %eax, %r14d
leaq 0x1f0(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x247aa
addl %r13d, %r14d
testq %rax, %rax
je 0x2650f
movl %r14d, %ecx
movq 0x28(%rax), %r14
movq 0x10(%r14), %rsi
cmpl %ecx, 0xc(%rsi)
movq %rsi, 0x8(%rsp)
jle 0x265b5
movl %r13d, 0x8(%rsi)
movl %ecx, %r13d
movl %ecx, 0xc(%rsi)
movq %r12, 0x10(%rsi)
leaq 0x70(%rsp), %rdx
callq 0x269e6
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
leaq 0x70(%rsp), %rdx
leaq 0x1c0(%rsp), %rcx
callq 0x25bb2
movl %eax, %r15d
leaq 0x188(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x28156
movl %r15d, (%rax)
movb $0x1, %bpl
leaq 0xa0(%rsp), %rdi
movq %r14, %rsi
callq 0x1717c
jmp 0x265ba
pushq $0x18
popq %rdi
callq 0x63b0
movq %rbp, (%rax)
movl %r13d, 0x8(%rax)
movl %r14d, %r13d
movl %r14d, 0xc(%rax)
movq %r12, 0x10(%rax)
movq %rax, 0x8(%rsp)
movq %rax, 0xd0(%rsp)
movq %r15, %rdi
leaq 0xd0(%rsp), %rsi
callq 0x1705a
movq %rax, 0xf8(%rsp)
leaq 0x1f0(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movq %rbx, %rdx
callq 0x23fea
movq 0x38(%rsp), %r14
leaq 0x70(%rsp), %r15
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x269e6
movq %r14, %rdi
movq 0x28(%rsp), %rsi
movq %r15, %rdx
leaq 0x1c0(%rsp), %rcx
callq 0x25bb2
movl %eax, 0xd0(%rsp)
leaq 0x188(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0xd0(%rsp), %rdx
callq 0x276d6
jmp 0x265b8
movl %ecx, %r13d
xorl %ebp, %ebp
movq 0x70(%rsp), %rax
cmpq %rax, 0x78(%rsp)
je 0x265cb
movq %rax, 0x78(%rsp)
cvtsi2ss %r13d, %xmm0
movss 0x34(%rsp), %xmm1
ucomiss %xmm0, %xmm1
leaq 0xa0(%rsp), %r15
jb 0x2668f
leaq 0x248(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2892a
testq %rax, %rax
je 0x26635
testb %bpl, %bpl
je 0x2668f
movq 0x28(%rax), %r14
leaq 0x188(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x28156
movl (%rax), %eax
movl %eax, 0x18(%r14)
leaq 0x140(%rsp), %rdi
movq %r14, %rsi
callq 0x26e6e
jmp 0x2668f
leaq 0x188(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x28156
movl (%rax), %eax
movq 0x8(%rsp), %rcx
movq %rcx, 0xf8(%rsp)
movl %eax, 0x100(%rsp)
leaq 0x140(%rsp), %rdi
movq %rbx, %rsi
callq 0x26d44
movq %rax, 0xd0(%rsp)
leaq 0x248(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0xd0(%rsp), %rdx
callq 0x281a2
movq 0x170(%rsp), %rax
addq $0x8, %rax
movq 0x38(%rsp), %rbp
jmp 0x262e9
movq 0x8(%rsp), %rbp
movq 0x10(%rsp), %r14
jmp 0x266da
movq 0x90(%rsp), %r12
jmp 0x26463
addq $0x8, %r12
movq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0x26bd4
testb %al, %al
jne 0x266eb
addq $0x8, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x26bd4
testb %al, %al
cmoveq %r14, %r12
movq %r12, %r15
jmp 0x2644a
movq 0x98(%rsp), %rax
movb $0x0, 0x40(%rax)
xorl %ebx, %ebx
addq $0xb0, %rbp
movq 0x28(%rsp), %rax
movl (%rax), %eax
leaq 0xf8(%rsp), %rsi
movl %eax, (%rsi)
movq %rbp, %rdi
callq 0x2769a
movl %ebx, (%rax)
leaq 0x248(%rsp), %rdi
callq 0x26fc6
leaq 0x140(%rsp), %rdi
callq 0x26ecc
leaq 0x188(%rsp), %rdi
callq 0x27084
leaq 0x280(%rsp), %rdi
callq 0x22af2
leaq 0x1f0(%rsp), %rdi
callq 0x22bb0
leaq 0xa0(%rsp), %rdi
callq 0x171f8
leaq 0x2b8(%rsp), %rdi
callq 0x61d0
leaq 0x228(%rsp), %rdi
callq 0x61d0
leaq 0x48(%rsp), %rdi
callq 0x61d0
leaq 0x1c0(%rsp), %rdi
callq 0x92ec
jmp 0x2680d
movq 0x38(%rbp), %rsi
movq (%rsi), %rax
leaq 0x1f0(%rsp), %rdi
movq %rbx, %rdx
callq *0x18(%rax)
leaq 0x1f0(%rsp), %rbx
movq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18466
movq %rbx, %rdi
callq 0x990e
movq (%r14), %r15
movq 0x8(%r14), %r14
addq $0xb0, %rbp
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rbx)
leaq 0x1f0(%rsp), %rsi
movq %rbp, %rdi
callq 0x2769a
subq %r15, %r14
shrq $0x3, %r14
decl %r14d
movl %r14d, (%rax)
movq 0x18(%rsp), %rbx
leaq 0x120(%rsp), %rdi
callq 0x990e
leaq 0x70(%rsp), %rdi
callq 0x990e
leaq 0x1d8(%rsp), %rdi
callq 0x235f6
movq %rbx, %rax
addq $0x2d8, %rsp            # imm = 0x2D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rsi
movq 0x18(%rsp), %rdx
callq 0x269e6
movl 0x6c(%rsp), %ebx
jmp 0x26701
jmp 0x2692b
jmp 0x2692b
jmp 0x2692b
jmp 0x2692b
jmp 0x2692b
jmp 0x2692b
jmp 0x2692b
jmp 0x2692b
jmp 0x2692b
jmp 0x2692b
jmp 0x2692b
jmp 0x2692b
jmp 0x2692b
jmp 0x2692b
jmp 0x268d7
jmp 0x268d7
jmp 0x2692b
jmp 0x2692b
jmp 0x2692b
movq %rax, %rbx
jmp 0x26948
jmp 0x268d2
jmp 0x268d2
jmp 0x268d2
movq %rax, %rbx
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x63c0
jmp 0x26955
movq %rax, %rbx
jmp 0x26955
movq %rax, %rbx
jmp 0x269ad
jmp 0x2692b
jmp 0x2692b
jmp 0x2692b
jmp 0x2692b
jmp 0x26905
jmp 0x26905
jmp 0x2692b
jmp 0x26905
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0x61d0
jmp 0x26908
jmp 0x26905
jmp 0x26905
movq %rax, %rbx
leaq 0x100(%rsp), %rdi
callq 0x26f92
jmp 0x2692e
jmp 0x2692b
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
callq 0x61d0
jmp 0x2692e
movq %rax, %rbx
leaq 0x248(%rsp), %rdi
callq 0x26fc6
leaq 0x140(%rsp), %rdi
callq 0x26ecc
leaq 0x188(%rsp), %rdi
callq 0x27084
leaq 0x280(%rsp), %rdi
callq 0x22af2
leaq 0x1f0(%rsp), %rdi
callq 0x22bb0
leaq 0xa0(%rsp), %rdi
callq 0x171f8
leaq 0x2b8(%rsp), %rdi
callq 0x61d0
leaq 0x228(%rsp), %rdi
callq 0x61d0
leaq 0x48(%rsp), %rdi
callq 0x61d0
leaq 0x1c0(%rsp), %rdi
callq 0x92ec
movq 0x18(%rsp), %r14
leaq 0x120(%rsp), %rdi
callq 0x990e
leaq 0x70(%rsp), %rdi
callq 0x990e
movq %r14, %rdi
callq 0x990e
leaq 0x1d8(%rsp), %rdi
callq 0x235f6
movq %rbx, %rdi
callq 0x6650