LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/heuristics.cpp
// Function: Goban::creates_eyes(int, bool) const
int Goban::creates_eyes(int point, bool color) const
{
  int neyes = 0;
  for (int i = 0; adjacent[point][i]; i++) {
    if (is_true_eye(adjacent[point][i], color, point)) {
      neyes++;
    }
  }
#ifdef DEBUG_INFO
  if (neyes) {
    std::cerr << point << " creates " << neyes << " eyes\n";
  }
#endif
  return neyes;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movslq %esi, %rax
leaq (%rax,%rax,4), %rax
movl 0xd63e8(%rdi,%rax,4), %esi
testl %esi, %esi
je 0x8b22
movq %rdi, %r14
leaq (%rdi,%rax,4), %r12
addq $0xd63ec, %r12          # imm = 0xD63EC
xorl %ebp, %ebp
movzbl %dl, %r15d
movq %r14, %rdi
movl %r15d, %edx
movl %ebx, %ecx
callq 0x5490
movzbl %al, %eax
addl %eax, %ebp
movl (%r12), %esi
addq $0x4, %r12
testl %esi, %esi
jne 0x8b02
jmp 0x8b24
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/heuristics.cpp
// Function: Goban::stones_around(int, int) const
bool Goban::stones_around(int point, int distance) const
{
  for (int i = 0; i < distance; i++) {
    for (int j = 0; j < 4*(i+1); j++) {
      int v =  within_manhattan[point][i][j];
      if (is_occupied(v)) return true;
    }
  }
  return false;
}

// Assembly:
testl %edx, %edx
setg %al
jle 0x90a5
pushq %rbx
leaq 0xdfca0(%rdi), %r9
movslq %esi, %rsi
movl %edx, %ecx
leaq (%rsi,%rsi,4), %rdx
shlq $0x6, %rdx
leaq (%rdi,%rdx), %rsi
xorl %r8d, %r8d
addq %r9, %rdx
leaq (%r8,%r8,4), %r9
shlq $0x4, %r9
movslq (%r9,%rdx), %r9
cmpq $0x0, 0x18(%rdi,%r9,8)
jne 0x90a4
incq %r8
leal (,%r8,4), %r9d
movl $0x37f29, %r10d         # imm = 0x37F29
leaq -0x37f28(%r10), %r11
cmpq %r9, %r11
jae 0x9095
movslq (%rsi,%r10,4), %rbx
incq %r10
cmpq $0x0, 0x18(%rdi,%rbx,8)
je 0x9075
cmpq %r9, %r11
jb 0x90a4
cmpq %rcx, %r8
setb %al
addq $0x50, %rsi
cmpq %rcx, %r8
jne 0x9050
popq %rbx
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/heuristics.cpp
// Function: Goban::bad_self_atari(int, bool) const
bool Goban::bad_self_atari(int point, bool color) const
{
  int last_lib = atari_last_liberty(point, color);
  if (last_lib == -1) return false;
#ifdef DEBUG_INFO
  std::cerr << "self_atari at " << point << "\n";
#endif

  //Only handle throw-ins up to 2 stones:?
  //if (neighbours_size(point, color) < 2) {
    if (total_liberties(last_lib, !color, 0) < 2) {
#ifdef DEBUG_INFO
      std::cerr << "snapback\n";
#endif  
      return false;
    }
    if (creates_eyes(point, !color) && !creates_eyes(last_lib, !color)) {
#ifdef DEBUG_INFO
        std::cerr << "throw-in\n";
#endif
      return false;
    }
  //}
  if (nakade_shape(point, color)) {
#ifdef DEBUG_INFO
    std::cerr << "nakade\n";
#endif
    return false;
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5b8, %rsp            # imm = 0x5B8
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
movl %r15d, 0x5ac(%r12)
movl %r15d, 0x8(%r12)
leaq 0x689e(%rip), %rax      # 0xfd20
movq %rax, (%r12)
movq %r12, %rcx
movl $0x1, %r8d
xorl %r9d, %r9d
callq 0x90a8
cmpl $0x1, %eax
setne %al
movl 0x8(%r12), %r12d
cmpl $-0x1, %r12d
sete %cl
orb %al, %cl
jne 0x9510
movl %ebp, %eax
xorb $0x1, %al
movzbl %al, %r13d
xorl %r15d, %r15d
movq %r14, %rdi
movl %r12d, %esi
movl %r13d, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x90a8
cmpl $0x2, %eax
jl 0x9510
movq %r14, %rdi
movl %ebx, %esi
movl %r13d, %edx
callq 0x8ad2
testl %eax, %eax
je 0x94f6
movq %r14, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0x8ad2
testl %eax, %eax
je 0x950d
movzbl %bpl, %edx
movq %r14, %rdi
movl %ebx, %esi
callq 0x9526
movl %eax, %r15d
xorb $0x1, %r15b
jmp 0x9510
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x5b8, %rsp            # imm = 0x5B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/heuristics.cpp
// Function: Goban::nakade_shape(int, bool) const
bool Goban::nakade_shape(int point, bool color) const
{
  int bulk = neighbour_bulkiness(point, color);
      
  switch(neighbours_size(point, color)) {
    case 2:
      return true;
      break;
    case 3:
      if (bulk == 3) return true;
      break;
    case 4:
      if (bulk == 4 || bulk == 3) return true;    //TODO.  
      break;
    case 5:
      if (bulk == 4) return true;
      break;
    default:
      return false;
  }
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
callq 0x9602
movl %eax, %ebx
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x53be
movl %eax, %ecx
addl $-0x2, %ecx
cmpl $0x3, %ecx
ja 0x9574
movb $0x1, %al
leaq 0x21f8(%rip), %rdx      # 0xb754
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
cmpl $0x3, %ebx
jne 0x9574
jmp 0x9576
addl $-0x3, %ebx
cmpl $0x2, %ebx
jb 0x9576
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x4, %ebx
jne 0x9574
jmp 0x9576
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/heuristics.cpp
// Function: Goban::neighbour_bulkiness(int, bool) const
int Goban::neighbour_bulkiness(int point, bool color) const
{
  GroupSet<4> neighbours;
  int nneigh = neighbour_groups(point, neighbours);
  int max_bulkiness = nneigh;
  for (int i = 0; i < nneigh; i++) {
    Group *neigh = neighbours[i];
    if (neigh->get_color() == color) {
      int bulk = bulkiness(neigh, point);
      if (bulk > max_bulkiness) max_bulkiness = bulk;
    }
  }
  return max_bulkiness;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movq %rsp, %rdx
movl $0x0, 0x30(%rdx)
movq $0x0, (%rdx)
callq 0x5210
movl %eax, %r15d
testl %eax, %eax
jle 0x965b
movl %r15d, %r12d
xorl %r13d, %r13d
movq (%rsp,%r13,8), %rsi
cmpb %bl, (%rsi)
jne 0x9653
movq %r14, %rdi
movl %ebp, %edx
callq 0x9588
cmpl %r15d, %eax
cmovgl %eax, %r15d
incq %r13
cmpq %r13, %r12
jne 0x963a
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/main.cpp
// Function: main
int main()
{

  //srand(unsigned(time(NULL)));
  init_genrand64(16669666165875248481ULL);

  GTP gtp;
  //gtp.perft(100000);
  gtp.GTP_loop();
  return 0;
}

// Assembly:
pushq %rbx
subq $0x100340, %rsp         # imm = 0x100340
movabsq $-0x18a972f11aa8729f, %rdi # imm = 0xE7568D0EE5578D61
movq %rdi, 0x6a93(%rip)      # 0x101f0
movl $0x1, %eax
movabsq $0x5851f42d4c957f2d, %rcx # imm = 0x5851F42D4C957F2D
leaq 0x6a7d(%rip), %rdx      # 0x101f0
movq %rdi, %rsi
shrq $0x3e, %rsi
xorq %rdi, %rsi
imulq %rcx, %rsi
addq %rax, %rsi
movq %rsi, (%rdx,%rax,8)
incq %rax
movq %rsi, %rdi
cmpq $0x138, %rax            # imm = 0x138
jne 0x9776
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x60c0
movq %rbx, %rdi
callq 0x66e8
movq %rsp, %rdi
callq 0x97d0
xorl %eax, %eax
addq $0x100340, %rsp         # imm = 0x100340
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x97d0
movq %rbx, %rdi
callq 0x3300
nop
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/tree.cpp
// Function: Node::copy_values(Node const*)
void Node::copy_values(const Node *orig)
 {
  child = 0;
  sibling = 0;
  visits = orig->visits;
  results = orig->results;
  rave_visits = orig->rave_visits;
  rave_results = orig->rave_results;
  prior_visits = orig->prior_visits;
  prior_results = orig->prior_results;
  move = orig->move;
 }

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movsd 0x8(%rsi), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x10(%rsi), %xmm0
movsd %xmm0, 0x10(%rdi)
movsd 0x18(%rsi), %xmm0
movsd %xmm0, 0x18(%rdi)
movsd 0x20(%rsi), %xmm0
movsd %xmm0, 0x20(%rdi)
movsd 0x28(%rsi), %xmm0
movsd %xmm0, 0x28(%rdi)
movsd 0x30(%rsi), %xmm0
movsd %xmm0, 0x30(%rdi)
movl (%rsi), %eax
movl %eax, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/tree.cpp
// Function: Node::set_move(int, Prior const&)
void Node::set_move(int mv, const Prior &prior)
{
  move = mv;
  rave_results = prior.prior;
  rave_visits = prior.equiv;
  prior_results = prior.prior;
  prior_visits = prior.equiv;
}

// Assembly:
movl %esi, (%rdi)
movsd (%rdx), %xmm0
movsd %xmm0, 0x20(%rdi)
movsd 0x8(%rdx), %xmm1
movsd %xmm1, 0x18(%rdi)
movsd %xmm0, 0x30(%rdi)
movsd %xmm1, 0x28(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/tree.cpp
// Function: Node::set_amaf(int, AmafBoard const&, bool, int)
void Node::set_amaf(int result, const AmafBoard &amaf, bool side, int depth)
{
  const double discount = 0.0; //0.0001;
  for (Node *next = child; next; next = next->sibling) {
    next->rave_results += result * amaf.value(next->move, depth, side, discount);
    next->rave_visits += amaf.value(next->move, depth, side, discount);
  }
}

// Assembly:
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x9ebd
cvtsi2sd %esi, %xmm0
movsd 0x19a3(%rip), %xmm1     # 0xb7c8
movsd 0x11f3(%rip), %xmm2     # 0xb020
movslq (%rax), %rsi
testq %rsi, %rsi
je 0x9e90
movl (%rdx,%rsi,4), %r9d
movl %r9d, %edi
negl %edi
testb %cl, %cl
cmovel %r9d, %edi
xorpd %xmm3, %xmm3
xorpd %xmm4, %xmm4
cmpl %r8d, %edi
jl 0x9e60
xorps %xmm4, %xmm4
cvtsi2sd %edi, %xmm4
mulsd %xmm1, %xmm4
addsd %xmm2, %xmm4
mulsd %xmm0, %xmm4
addsd 0x20(%rax), %xmm4
movsd %xmm4, 0x20(%rax)
movl (%rdx,%rsi,4), %edi
movl %edi, %esi
negl %esi
testb %cl, %cl
cmovel %edi, %esi
cmpl %r8d, %esi
jl 0x9ea6
xorps %xmm3, %xmm3
cvtsi2sd %esi, %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
jmp 0x9ea6
xorpd %xmm3, %xmm3
movapd %xmm0, %xmm4
mulsd %xmm3, %xmm4
addsd 0x20(%rax), %xmm4
movsd %xmm4, 0x20(%rax)
addsd 0x18(%rax), %xmm3
movsd %xmm3, 0x18(%rax)
movq 0x40(%rax), %rax
testq %rax, %rax
jne 0x9e2d
retq
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/tree.cpp
// Function: Node::get_value(double) const
double Node::get_value(double parent_visits) const
{
  const double BIAS = 1.0/3000, UCTK = 0.0;
  if (visits) {
    if (rave_visits) {
      double beta = rave_visits/(rave_visits + visits + rave_visits*visits*BIAS);
      return (1.0-beta)*results/visits + beta*rave_results/rave_visits;
    } else {
      return results/visits + UCTK*sqrt(log(parent_visits)/visits);
    }
  } else if (rave_visits) {
      return rave_results/rave_visits;
  }
  return 1.0;   //first player urgency.
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0x8(%rdi), %xmm2
movsd 0x18(%rdi), %xmm1
xorpd %xmm3, %xmm3
ucomisd %xmm3, %xmm2
jne 0x9edc
jnp 0x9f2c
ucomisd %xmm3, %xmm1
jne 0x9ee4
jnp 0x9f3f
movapd %xmm2, %xmm0
addsd %xmm1, %xmm0
movapd %xmm2, %xmm3
mulsd %xmm1, %xmm3
mulsd 0x18d4(%rip), %xmm3     # 0xb7d0
addsd %xmm0, %xmm3
movapd %xmm1, %xmm0
divsd %xmm3, %xmm0
movsd 0x1110(%rip), %xmm3     # 0xb020
subsd %xmm0, %xmm3
mulsd 0x10(%rbx), %xmm3
divsd %xmm2, %xmm3
mulsd 0x20(%rbx), %xmm0
divsd %xmm1, %xmm0
addsd %xmm3, %xmm0
jmp 0x9f85
ucomisd %xmm3, %xmm1
jne 0x9f34
jnp 0x9f68
movsd 0x20(%rbx), %xmm0
divsd %xmm1, %xmm0
jmp 0x9f85
movsd 0x10(%rbx), %xmm1
divsd %xmm2, %xmm1
movsd %xmm1, 0x8(%rsp)
callq 0x3170
divsd 0x8(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x9f72
sqrtsd %xmm0, %xmm0
jmp 0x9f7b
movsd 0x10b0(%rip), %xmm0     # 0xb020
jmp 0x9f85
callq 0x3160
xorpd %xmm1, %xmm1
mulsd %xmm1, %xmm0
addsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/tree.cpp
// Function: Node::select_child() const
Node *Node::select_child() const
{
  double best_value = -1;
  Node *RAVE_child = 0;
  for (Node *next = child; next; next = next->sibling) {
    if (next->get_value(visits) > best_value) {
      best_value = next->get_value(visits);
      RAVE_child = next;
    }
  }
  return RAVE_child;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x38(%rdi), %r14
testq %r14, %r14
je 0x9fe8
movq %rdi, %rbx
movsd 0x182f(%rip), %xmm0     # 0xb7d8
movsd %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
callq 0x9ebe
ucomisd 0x8(%rsp), %xmm0
jbe 0x9fdd
movsd 0x8(%rbx), %xmm0
movq %r14, %rdi
callq 0x9ebe
movsd %xmm0, 0x8(%rsp)
movq %r14, %r15
movq 0x40(%r14), %r14
testq %r14, %r14
jne 0x9fb2
jmp 0x9feb
xorl %r15d, %r15d
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/tree.cpp
// Function: Node::get_best_child() const
Node *Node::get_best_child() const
{
  //return select_child();
  Node *best_child = 0;
  double best_visits = 0;
  for (Node *next = child; next; next = next->sibling) {
    double curr_visits = next->visits + next->rave_visits;
    if (curr_visits > best_visits) {
      best_visits = curr_visits;
      best_child= next;
    }
  }
  return best_child;
}

// Assembly:
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
je 0xa02b
xorpd %xmm0, %xmm0
xorl %eax, %eax
movsd 0x8(%rcx), %xmm1
addsd 0x18(%rcx), %xmm1
ucomisd %xmm0, %xmm1
cmovaq %rcx, %rax
maxsd %xmm0, %xmm1
movq 0x40(%rcx), %rcx
movapd %xmm1, %xmm0
testq %rcx, %rcx
jne 0xa007
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/tree.cpp
// Function: Tree::Tree(int, Goban*)
Tree::Tree(int maxsize, Goban *goban)
{
  active = 0;
  this->maxsize = maxsize;
  this->goban = goban;
  root[0] = new Node[maxsize];
  root[1] = new Node[maxsize];
  root[0]->reset();
  root[1]->reset();
  size[0] = 1;
  size[1] = 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movl %ebp, 0x1c(%rdi)
movl %esi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
movslq %esi, %rax
movl $0x48, %ecx
mulq %rcx
movq $-0x1, %r14
cmovnoq %rax, %r14
movq %r14, %rdi
callq 0x3030
movq %rax, %r15
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x3030
movq %rax, 0x8(%rbx)
movl %ebp, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r15)
movups %xmm0, 0x8(%r15)
movups %xmm0, 0x38(%r15)
movl %ebp, (%rax)
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x38(%rax)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/tree.cpp
// Function: Tree::clear()
void Tree::clear()
{
  active = 0;
  root[0]->reset();
  root[1]->reset();
  size[0] = 1;
  size[1] = 1;
}

// Assembly:
xorl %eax, %eax
movl %eax, 0x1c(%rdi)
movq (%rdi), %rcx
movl %eax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rcx)
movups %xmm0, 0x18(%rcx)
movups %xmm0, 0x38(%rcx)
movq 0x8(%rdi), %rcx
movl %eax, (%rcx)
movups %xmm0, 0x8(%rcx)
movups %xmm0, 0x18(%rcx)
movups %xmm0, 0x38(%rcx)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/tree.cpp
// Function: Tree::insert(Node*, int, Prior const&)
Node *Tree::insert(Node *parent, int move, const Prior &prior)
{
  if (size[active] < maxsize) {
    Node *child = root[active] + size[active]++;
    child->reset();
    parent->add_child(child);
    child->set_move(move, prior);
    return child;
  } else {
    std::cerr << "WARNING: Out of memory!\n";
    return 0;
  }
}

// Assembly:
pushq %rax
movslq 0x1c(%rdi), %rax
movslq 0x10(%rdi,%rax,4), %r8
cmpl 0x18(%rdi), %r8d
jge 0xa57b
movq (%rdi,%rax,8), %r9
leal 0x1(%r8), %r10d
movl %r10d, 0x10(%rdi,%rax,4)
leaq (%r8,%r8,8), %rax
leaq (%r9,%rax,8), %rax
movl $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x38(%rax)
movq 0x38(%rsi), %rdi
testq %rdi, %rdi
je 0xa597
movq %rdi, %rsi
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
jne 0xa569
addq $0x40, %rsi
jmp 0xa59b
movq 0x5a6e(%rip), %rdi      # 0xfff0
leaq 0x1276(%rip), %rsi      # 0xb7ff
movl $0x18, %edx
callq 0x31f0
xorl %eax, %eax
jmp 0xa5bd
addq $0x38, %rsi
movq %rax, (%rsi)
movl %edx, (%rax)
movsd (%rcx), %xmm0
movsd %xmm0, 0x20(%rax)
movsd 0x8(%rcx), %xmm1
movsd %xmm1, 0x18(%rax)
movsd %xmm0, 0x30(%rax)
movsd %xmm1, 0x28(%rax)
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/tree.cpp
// Function: Tree::insert(Node*, Node const*)
Node *Tree::insert(Node *parent, const Node *orig)
{
  if (size[1-active] < maxsize) {
    Node *child = root[1-active] + size[1-active]++;
    child->copy_values(orig);
    parent->add_child(child);
    return child;
  } else {
    std::cerr << "WARNING: Out of memory!\n";
    return 0;
  }
}

// Assembly:
pushq %rax
movslq 0x1c(%rdi), %rcx
movl $0x1, %eax
subq %rcx, %rax
movslq 0x10(%rdi,%rax,4), %rcx
cmpl 0x18(%rdi), %ecx
jge 0xa64e
movq (%rdi,%rax,8), %r8
leal 0x1(%rcx), %r9d
movl %r9d, 0x10(%rdi,%rax,4)
leaq (%rcx,%rcx,8), %rax
leaq (%r8,%rax,8), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rax)
movsd 0x8(%rdx), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x10(%rdx), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x18(%rdx), %xmm0
movsd %xmm0, 0x18(%rax)
movsd 0x20(%rdx), %xmm0
movsd %xmm0, 0x20(%rax)
movsd 0x28(%rdx), %xmm0
movsd %xmm0, 0x28(%rax)
movsd 0x30(%rdx), %xmm0
movsd %xmm0, 0x30(%rax)
movl (%rdx), %ecx
movl %ecx, (%rax)
movq 0x38(%rsi), %rcx
testq %rcx, %rcx
je 0xa66a
movq %rcx, %rdx
movq 0x40(%rcx), %rcx
testq %rcx, %rcx
jne 0xa63c
movq %rax, 0x40(%rdx)
jmp 0xa66e
movq 0x599b(%rip), %rdi      # 0xfff0
leaq 0x11a3(%rip), %rsi      # 0xb7ff
movl $0x18, %edx
callq 0x31f0
xorl %eax, %eax
jmp 0xa66e
movq %rax, 0x38(%rsi)
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/tree.cpp
// Function: Tree::promote(int)
int Tree::promote(int new_root)
{
  for (Node *n = root[active]->get_child(); n; n = n->get_sibling()) {
    if (n->get_move() == new_root) {
      root[1-active]->copy_values(n);
      copy_recursive(root[1-active], n);
      clear_active();
      active = 1-active;
      return active;
    }
  }
  clear();
  return active;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x1c(%rdi), %rax
movq (%rdi,%rax,8), %rcx
movq 0x38(%rcx), %rdx
testq %rdx, %rdx
sete %bpl
je 0xa6d9
cmpl %esi, (%rdx)
je 0xa6de
movq 0x40(%rdx), %rdx
jmp 0xa6c6
jmp 0xa779
movl $0x1, %ecx
movl $0x1, %esi
subq %rax, %rsi
movq (%rbx,%rsi,8), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rax)
movsd 0x8(%rdx), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x10(%rdx), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x18(%rdx), %xmm0
movsd %xmm0, 0x18(%rax)
movsd 0x20(%rdx), %xmm0
movsd %xmm0, 0x20(%rax)
movsd 0x28(%rdx), %xmm0
movsd %xmm0, 0x28(%rax)
movsd 0x30(%rdx), %xmm0
movsd %xmm0, 0x30(%rax)
movl (%rdx), %esi
movl %esi, (%rax)
movslq 0x1c(%rbx), %rax
subq %rax, %rcx
movq (%rbx,%rcx,8), %rsi
movq %rbx, %rdi
callq 0xa670
movslq 0x1c(%rbx), %rcx
movl $0x1, %eax
movl %eax, 0x10(%rbx,%rcx,4)
movslq 0x1c(%rbx), %rcx
movq (%rbx,%rcx,8), %rcx
movl $0x0, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rcx)
movups %xmm0, 0x18(%rcx)
movups %xmm0, 0x38(%rcx)
subl 0x1c(%rbx), %eax
movl %eax, 0x1c(%rbx)
testb %bpl, %bpl
je 0xa7ba
xorl %eax, %eax
movl %eax, 0x1c(%rbx)
movq (%rbx), %rcx
movl %eax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rcx)
movups %xmm0, 0x18(%rcx)
movups %xmm0, 0x38(%rcx)
movq 0x8(%rbx), %rcx
movl %eax, (%rcx)
movups %xmm0, 0x8(%rcx)
movups %xmm0, 0x18(%rcx)
movups %xmm0, 0x38(%rcx)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x10(%rbx)
movl 0x1c(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/tree.cpp
// Function: Tree::expand(Node*, int const*, int, Prior const*)
int Tree::expand(Node *parent, const int *moves, int nmovs, const Prior priors[])
{
  //if (parent->has_childs()) return 0; //No need to expand, but we check before calling.
  for (int i = 0; i < nmovs; i++) {
    if (insert(parent, moves[i], priors[moves[i]]) == 0) {  //Out of memory.
      return -1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %ecx, %ecx
setg %r13b
jle 0xa833
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movslq (%rdx), %rdx
movq %rdx, %rcx
shlq $0x4, %rcx
addq %r8, %rcx
callq 0xa526
testq %rax, %rax
je 0xa833
movl %ebp, %r13d
movl $0x1, %ecx
movq %rcx, %rbp
cmpq %rcx, %r13
je 0xa82c
movslq (%r14,%rbp,4), %rdx
movq %rdx, %rcx
shlq $0x4, %rcx
addq %rbx, %rcx
movq %r12, %rdi
movq %r15, %rsi
callq 0xa526
leaq 0x1(%rbp), %rcx
testq %rax, %rax
jne 0xa802
cmpq %r13, %rbp
setb %r13b
movzbl %r13b, %eax
negl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/tree.cpp
// Function: Tree::print(Node*, int, int) const
void Tree::print(Node *node, int threshold, int depth) const
{
  for (int i = 0; i < depth; i++) std::cerr << "  ";
  std::cerr << "|->";
  node->print(goban->get_size());
  
  Node *childs[MAXSIZE2] = {0};
  int len = 0;
  for (Node *child = node->get_child(); child; child=child->get_sibling()) {
    if (child->get_visits() >= threshold) childs[len++] = child;
  }

  while (true) {
    int best = -1, visits = 0;
    for (int i = 0; i < len; i++) {
      if (childs[i] && childs[i]->get_visits() > visits) {
        best = i;
        visits = childs[best]->get_visits();
      }
    }
    if (best < 0) break;
    if (childs[best]->get_move()) print(childs[best], threshold, depth+1);
    childs[best] = 0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb58, %rsp            # imm = 0xB58
movl %ecx, %ebp
movl %edx, 0xc(%rsp)
movq %rsi, %r15
movq %rdi, %r14
testl %ecx, %ecx
jle 0xa88d
movq 0x5780(%rip), %r12      # 0xfff0
leaq 0xc1d(%rip), %r13       # 0xb494
movl %ebp, %ebx
movl $0x2, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x31f0
decl %ebx
jne 0xa879
movq 0x575c(%rip), %rdi      # 0xfff0
leaq 0xf7d(%rip), %rsi       # 0xb818
movl $0x3, %edx
callq 0x31f0
movq 0x20(%r14), %rax
movl 0x8(%rax), %esi
movq %r15, %rdi
callq 0xa02e
leaq 0x10(%rsp), %rdi
xorl %r12d, %r12d
movl $0xb48, %edx            # imm = 0xB48
xorl %esi, %esi
callq 0x30e0
movq 0x38(%r15), %rax
testq %rax, %rax
movl 0xc(%rsp), %r13d
je 0xa8fd
cvtsi2sd %r13d, %xmm0
xorl %r12d, %r12d
movsd 0x8(%rax), %xmm1
ucomisd %xmm0, %xmm1
jb 0xa8f4
movslq %r12d, %rcx
incl %r12d
movq %rax, 0x10(%rsp,%rcx,8)
movq 0x40(%rax), %rax
testq %rax, %rax
jne 0xa8de
incl %ebp
movl %r12d, %r15d
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testl %r15d, %r15d
jle 0xa93c
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x10(%rsp,%rax,8), %rdx
testq %rdx, %rdx
je 0xa934
movsd 0x8(%rdx), %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xa934
cvttsd2si %xmm0, %ecx
movl %eax, %r12d
incq %rax
cmpq %rax, %r15
jne 0xa911
testl %r12d, %r12d
js 0xa969
movl %r12d, %ebx
movq 0x10(%rsp,%rbx,8), %rsi
cmpl $0x0, (%rsi)
je 0xa95b
movq %r14, %rdi
movl %r13d, %edx
movl %ebp, %ecx
callq 0xa848
movq $0x0, 0x10(%rsp,%rbx,8)
testl %r12d, %r12d
jns 0xa902
addq $0xb58, %rsp            # imm = 0xB58
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/antoniogarro[P]Hara/zobrist.cpp
// Function: Zobrist::Zobrist()
Zobrist::Zobrist()
{
  zob_key = 0;
  zob_side = genrand64_int64();
  for(int i = 0; i < MAXSIZE2; i++){
    zob_points [0][i] = genrand64_int64();
    zob_points [1][i] = genrand64_int64();
    zob_ko[i] = genrand64_int64();
  }
  clear_history();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, (%rdi)
callq 0xaca4
movq %rax, 0x8(%rbx)
movq $-0x169, %r14           # imm = 0xFE97
callq 0xaca4
movq %rax, 0xb58(%rbx,%r14,8)
callq 0xaca4
movq %rax, 0x16a0(%rbx,%r14,8)
callq 0xaca4
movq %rax, 0x21e8(%rbx,%r14,8)
incq %r14
jne 0xac4e
xorps %xmm0, %xmm0
movups %xmm0, 0x2208(%rbx)
movups %xmm0, 0x21f8(%rbx)
movups %xmm0, 0x21e8(%rbx)
movl $0x0, 0x2218(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/zengfenfei[P]codility/src/FrogRiverOne.cpp
// Function: solution(int, std::vector<int, std::allocator<int>>&)
int solution(int X, vector<int> &A) {
	// write your code in C++11 (g++ 4.8.2)
	vector<bool> hasLeaves(X, false);
	int validLeaves = 0;
	for (unsigned int i = 0; i < A.size(); i++) {
		bool has = hasLeaves[A[i] - 1];
		if (!has) {
			hasLeaves[A[i] - 1] = true;
			validLeaves++;
			if (validLeaves == X) {
				return i;
			}
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movl %edi, -0x30(%rbp)
movslq %edi, %rsi
leaq -0x2a(%rbp), %rdx
movb $0x0, (%rdx)
leaq -0x58(%rbp), %rdi
leaq -0x29(%rbp), %rcx
callq 0x1410
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
subq %rax, %rdx
je 0x131a
sarq $0x2, %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
xorl %ecx, %ecx
movl $0x1, %edi
movq -0x58(%rbp), %r8
leaq 0x3f(%rsi), %r9
xorl %r11d, %r11d
movslq (%rax,%rcx,4), %rbx
leaq -0x1(%rbx), %rcx
addq $0x3e, %rbx
testq %rcx, %rcx
cmovnsq %rcx, %rbx
sarq $0x6, %rbx
movq %rcx, %r14
andq %r9, %r14
xorl %r15d, %r15d
cmpq %rsi, %r14
setbe %r15b
movl $0x1, %r13d
shlq %cl, %r13
leaq (%r8,%rbx,8), %rbx
movq -0x8(%rbx,%r15,8), %r14
movb $0x1, %r12b
btq %rcx, %r14
jb 0x1302
leal -0x1(%rdi), %ecx
leaq -0x8(,%r15,8), %r15
orq %r14, %r13
movq %r13, (%rbx,%r15)
incl %r11d
cmpl -0x30(%rbp), %r11d
setne %r12b
cmovel %ecx, %r10d
testb %r12b, %r12b
je 0x1317
movl %edi, %ecx
incl %edi
cmpq %rcx, %rdx
ja 0x129f
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x131a
movl %r10d, %ebx
movq -0x58(%rbp), %rdi
testq %rdi, %rdi
je 0x1343
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x10a0
xorl %eax, %eax
movq %rax, -0x58(%rbp)
movl %eax, -0x50(%rbp)
movq %rax, -0x48(%rbp)
movl %eax, -0x40(%rbp)
movq %rax, -0x38(%rbp)
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/zengfenfei[P]codility/src/FrogRiverOne.cpp
// Function: main
int main() {
	vector<int> A(8);
	A[0] = 1;
	A[1] = 3;
	A[2] = 1;
	A[3] = 4;
	A[4] = 2;
	A[5] = 3;
	A[6] = 5;
	A[7] = 4;
	cout << solution(5, A) << '\n';	// 6
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movl $0x20, %edi
callq 0x1090
movq %rax, %rbx
movq %rax, (%r14)
movq %rax, 0x8(%r14)
addq $0x20, %rax
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movq %rax, 0x8(%r14)
movaps 0xc6d(%rip), %xmm0      # 0x2010
movups %xmm0, (%rbx)
movaps 0xc73(%rip), %xmm0      # 0x2020
movups %xmm0, 0x10(%rbx)
movl $0x5, %edi
movq %r14, %rsi
callq 0x123c
movq 0x2c13(%rip), %rdi      # 0x3fd8
movl %eax, %esi
callq 0x10d0
leaq -0x11(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x10b0
movl $0x20, %esi
movq %rbx, %rdi
callq 0x10a0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0x20, %esi
movq %rbx, %rdi
callq 0x10a0
movq %r14, %rdi
callq 0x10e0
// File: /workspace/github_cpp_makefile_star2_O1/kage08[P]RegexLibrary/Resource.cpp
// Function: NFA::NFA(std::vector<char, std::allocator<char>>&, char)
NFA::NFA(vector<char>& alph, char c){
      if(find(alph.begin(),alph.end(),c)==alph.end() && c!='@'){
        cerr<<"Invalid initialization of simple NFA\n";
        exit(0);
      }


      noStates=2;

      Trans=vector<set<pair<char,uLong> > >(noStates,set<pair<char,uLong> >());
      alphabet=alph;
      addTransition(0,1,c);
      acceptStates.insert(1);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r13
movq %rdi, %r15
leaq 0xe(%rsp), %rax
movb %dl, (%rax)
leaq 0x8(%rdi), %rbx
xorl %ecx, %ecx
movq %rcx, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x28(%rdi), %rdx
movl $0x0, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
movq %rdx, 0x38(%rdi)
movq %rdx, 0x40(%rdi)
leaq 0x50(%rdi), %r12
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
movq %rax, %rdx
callq 0x53bd
cmpq 0x8(%r13), %rax
jne 0x25f3
cmpb $0x40, 0xe(%rsp)
jne 0x26ee
movq $0x2, (%r15)
leaq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x8(%rax)
movaps %xmm0, 0x18(%rax)
movaps %xmm0, -0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq $0x0, 0x20(%rax)
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rdx
leaq 0xf(%rsp), %rcx
movl $0x2, %esi
callq 0x4634
leaq 0x60(%rsp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%r15), %rax
movups 0x10(%r15), %xmm0
leaq 0x48(%rsp), %rbp
movq (%rbp), %rcx
movq %rcx, 0x8(%r15)
movq 0x8(%rbp), %rcx
movq %rcx, 0x10(%r15)
movq 0x10(%rbp), %rcx
movq %rcx, 0x18(%r15)
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movq %rax, (%rdi)
movups %xmm0, 0x8(%rdi)
movq %rcx, (%rbp)
movq %rdx, 0x8(%rbp)
movq %rsi, 0x10(%rbp)
callq 0x46ce
movq %rbp, %rdi
callq 0x46ce
leaq 0x10(%rsp), %rdi
callq 0x4800
movq %r12, %rdi
movq %r13, %rsi
callq 0x4710
movb 0xe(%rsp), %al
movq (%rbx), %rdi
leaq 0x10(%rsp), %rsi
movb %al, (%rsi)
movq $0x1, 0x8(%rsi)
callq 0x5562
leaq 0x10(%rsp), %rsi
movq $0x1, (%rsi)
movq %r14, %rdi
callq 0x5450
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x78fb(%rip), %rdi      # 0x9ff0
leaq 0x4974(%rip), %rsi      # 0x7070
callq 0x2160
xorl %edi, %edi
callq 0x21d0
jmp 0x271b
movq %rax, %r13
leaq 0x10(%rsp), %rdi
callq 0x4800
jmp 0x271e
jmp 0x271b
movq %rax, %r13
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2733
movq 0x60(%r15), %rsi
subq %rdi, %rsi
callq 0x2180
movq %r14, %rdi
callq 0x4850
movq %rbx, %rdi
callq 0x46ce
movq %r13, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O1/kage08[P]RegexLibrary/Resource.cpp
// Function: Kleeny(NFA&)
NFA Kleeny(NFA& A){
  NFA B=A;
  for(uLong f:B.acceptStates)
    B.addTransition(f,0,'@');
  B.acceptStates.insert(0);
  return B;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
addq $0x8, %rsi
movq %r14, %rdi
callq 0x4b2a
leaq 0x20(%rbx), %r15
leaq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x4e56
leaq 0x50(%rbx), %rdi
addq $0x50, %r12
movq %r12, %rsi
callq 0x4bc6
movq 0x38(%rbx), %r12
leaq 0x28(%rbx), %rbp
cmpq %rbp, %r12
je 0x2c53
leaq 0x8(%rsp), %r13
movq 0x20(%r12), %rax
leaq (%rax,%rax,2), %rdi
shlq $0x4, %rdi
addq (%r14), %rdi
movb $0x40, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq %r13, %rsi
callq 0x5562
movq %r12, %rdi
callq 0x21b0
movq %rax, %r12
cmpq %rbp, %rax
jne 0x2c1d
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
movq %r15, %rdi
callq 0x5450
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c95
movq %rax, %r12
movq %r15, %rdi
callq 0x4850
jmp 0x2c8b
movq %rax, %r12
movq %r14, %rdi
callq 0x46ce
jmp 0x2ca0
movq %rax, %r12
movq %rbx, %rdi
callq 0x47c6
movq %r12, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/kage08[P]RegexLibrary/Resource.cpp
// Function: concat(NFA&, NFA&)
NFA concat(NFA& A, NFA& B){
  NFA C(A.noStates+B.noStates,A.alphabet);
  for(uLong i=0;i<A.noStates;i++){
    for(auto pb: A.Trans[i])
      C.addTransition(i,pb.second,pb.first);
  }
  for(uLong i=0;i<B.noStates;i++){
    for(auto pb: B.Trans[i])
      C.addTransition(i+A.noStates,pb.second+A.noStates,pb.first);
  }
  for(uLong f:A.acceptStates)
    C.addTransition(f,A.noStates,'@');
  for(uLong f: B.acceptStates)
    C.acceptStates.insert(f+A.noStates);

  return C;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, 0x18(%rsp)
movq (%rdx), %rsi
addq (%r15), %rsi
leaq 0x50(%r15), %rdx
callq 0x243c
cmpq $0x0, (%r15)
je 0x2d3c
xorl %ecx, %ecx
leaq 0x8(%rsp), %r12
movq 0x8(%r15), %rax
movq %rcx, 0x20(%rsp)
leaq (%rcx,%rcx,2), %r14
shlq $0x4, %r14
leaq (%rax,%r14), %rbp
addq $0x8, %rbp
movq 0x10(%rbp), %r13
cmpq %rbp, %r13
je 0x2d2f
movb 0x20(%r13), %al
movq 0x28(%r13), %rcx
movq 0x8(%rbx), %rdi
addq %r14, %rdi
movb %al, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %r12, %rsi
callq 0x5562
movq %r13, %rdi
callq 0x21b0
movq %rax, %r13
cmpq %rbp, %rax
jne 0x2cff
movq 0x20(%rsp), %rcx
incq %rcx
cmpq (%r15), %rcx
jb 0x2cdd
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x2dc3
xorl %ecx, %ecx
leaq 0x8(%rsp), %r12
movq 0x8(%rax), %rax
movq %rcx, 0x20(%rsp)
leaq (%rcx,%rcx,2), %r14
shlq $0x4, %r14
leaq (%rax,%r14), %rbp
addq $0x8, %rbp
movq 0x10(%rbp), %r13
cmpq %rbp, %r13
je 0x2db1
movb 0x20(%r13), %al
movq (%r15), %rcx
movq 0x28(%r13), %rdx
addq %rcx, %rdx
movq 0x8(%rbx), %rsi
addq %r14, %rsi
leaq (%rcx,%rcx,2), %rdi
shlq $0x4, %rdi
addq %rsi, %rdi
movb %al, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %r12, %rsi
callq 0x5562
movq %r13, %rdi
callq 0x21b0
movq %rax, %r13
cmpq %rbp, %rax
jne 0x2d70
movq 0x20(%rsp), %rcx
incq %rcx
movq 0x18(%rsp), %rax
cmpq (%rax), %rcx
jb 0x2d4e
movq 0x38(%r15), %r12
leaq 0x28(%r15), %r14
cmpq %r14, %r12
je 0x2e0b
leaq 0x8(%rsp), %r13
movq 0x20(%r12), %rax
movq (%r15), %rcx
leaq (%rax,%rax,2), %rdi
shlq $0x4, %rdi
addq 0x8(%rbx), %rdi
movb $0x40, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %r13, %rsi
callq 0x5562
movq %r12, %rdi
callq 0x21b0
movq %rax, %r12
cmpq %r14, %rax
jne 0x2dd5
movq 0x18(%rsp), %r14
movq 0x38(%r14), %r12
addq $0x28, %r14
cmpq %r14, %r12
je 0x2e4e
leaq 0x20(%rbx), %r13
leaq 0x8(%rsp), %rbp
movq 0x20(%r12), %rax
addq (%r15), %rax
movq %rax, 0x8(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x5450
movq %r12, %rdi
callq 0x21b0
movq %rax, %r12
cmpq %r14, %rax
jne 0x2e26
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e66
jmp 0x2e66
jmp 0x2e66
movq %rax, %r14
movq %rbx, %rdi
callq 0x47c6
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/kage08[P]RegexLibrary/Resource.cpp
// Function: printNFA(NFA&)
void printNFA(NFA& A){
  cout<<A.noStates<<endl;
  for(char c:A.alphabet)
    cout<<c<<" ";
  cout<<endl;
  for(uLong f: A.acceptStates)
    cout<<f<<" ";
  cout<<endl;
  for(uLong i=0;i<A.noStates;i++){
    for(auto pb: A.Trans[i])
      cout<<i<<" "<<pb.second<<" "<<pb.first<<endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r12
movq (%rdi), %rsi
movq 0x6bc8(%rip), %r14      # 0x9fc8
movq %r14, %rdi
callq 0x20f0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x50(%r12), %rbx
movq %r12, 0x18(%rsp)
movq 0x58(%r12), %rbp
cmpq %rbp, %rbx
je 0x3487
movq 0x6b7b(%rip), %r15      # 0x9fc8
leaq 0xe(%rsp), %r12
leaq 0x3c3d(%rip), %r13      # 0x7096
movb (%rbx), %al
movb %al, 0xe(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x21a0
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21a0
incq %rbx
cmpq %rbp, %rbx
jne 0x3459
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x18(%rsp), %rbp
movq 0x38(%rbp), %r15
leaq 0x28(%rbp), %rbx
cmpq %rbx, %r15
je 0x34fa
movq 0x6b01(%rip), %r12      # 0x9fc8
leaq 0x3bc8(%rip), %r13      # 0x7096
movq 0x20(%r15), %rsi
movq %r12, %rdi
callq 0x20f0
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x21a0
movq %r15, %rdi
callq 0x21b0
movq %rax, %r15
cmpq %rbx, %rax
jne 0x34ce
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
cmpq $0x0, (%rbp)
je 0x362c
movq $0x0, 0x10(%rsp)
leaq 0x3b5a(%rip), %r15      # 0x7096
leaq 0xf(%rsp), %r13
movq 0x8(%rbp), %rax
movq 0x10(%rsp), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $0x8, %rax
movq 0x10(%rax), %rbp
movq %rax, 0x20(%rsp)
cmpq %rax, %rbp
je 0x3610
movb 0x20(%rbp), %r12b
movq 0x28(%rbp), %rbx
movq 0x6a4e(%rip), %rdi      # 0x9fc8
movq 0x10(%rsp), %rsi
callq 0x20f0
movq %r15, %r14
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x21a0
movq %r15, %rdi
movq %r14, %r15
movq %rbx, %rsi
callq 0x20f0
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x21a0
movb %r12b, 0xf(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x21a0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %rbp, %rdi
callq 0x21b0
movq %rax, %rbp
cmpq 0x20(%rsp), %rax
jne 0x356b
movq 0x10(%rsp), %rcx
incq %rcx
movq 0x18(%rsp), %rbp
movq %rcx, 0x10(%rsp)
cmpq (%rbp), %rcx
jb 0x3541
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kage08[P]RegexLibrary/Resource.cpp
// Function: NFA::acceptString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool NFA::acceptString(string st){
  set<uLong> currStates;
  currStates.insert(0);
  currStates=step(currStates,'@');
  for(char c:st){
    currStates=step(currStates,c);
  }
  for(uLong f: acceptStates)
    if(currStates.find(f)!=currStates.end()) return true;
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movl $0x0, (%r15)
xorl %eax, %eax
movq %rax, 0x8(%r15)
movq %r15, 0x10(%r15)
movq %r15, 0x18(%r15)
movq %rax, 0x20(%r15)
leaq 0x38(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x5450
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %rbx, %rsi
movl $0x40, %ecx
callq 0x2788
leaq 0x8(%rsp), %rdi
callq 0x5160
movq 0x48(%rsp), %rax
testq %rax, %rax
je 0x36e3
leaq 0x40(%rsp), %rcx
movl (%rcx), %edx
movl %edx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movups 0x10(%rcx), %xmm0
movups %xmm0, 0x20(%rsp)
movq %r15, 0x8(%rax)
movq 0x20(%rcx), %rax
movq %rax, 0x30(%rsp)
xorl %eax, %eax
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
leaq 0x38(%rsp), %rdi
callq 0x4850
movq 0x8(%r14), %r13
testq %r13, %r13
je 0x3785
movq (%r14), %rbp
leaq 0x38(%rsp), %r14
leaq 0x8(%rsp), %r15
xorl %r12d, %r12d
movsbl (%rbp,%r12), %ecx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2788
movq %r15, %rdi
callq 0x5160
movq 0x48(%rsp), %rax
testq %rax, %rax
je 0x3775
movl 0x40(%rsp), %ecx
movl %ecx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movups 0x50(%rsp), %xmm0
movups %xmm0, 0x20(%rsp)
leaq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
xorl %ecx, %ecx
movq %rcx, 0x48(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x50(%rsp)
movq %rax, 0x58(%rsp)
movq %rcx, 0x60(%rsp)
movq %r14, %rdi
callq 0x4850
incq %r12
cmpq %r12, %r13
jne 0x370a
movq 0x38(%rbx), %rax
addq $0x28, %rbx
cmpq %rbx, %rax
setne %bpl
je 0x37f3
movq 0x18(%rsp), %r14
leaq 0x10(%rsp), %r15
movq 0x20(%rax), %rcx
movq %r15, %rdx
testq %r14, %r14
je 0x37ca
movq %r14, %rsi
movq %r15, %rdx
xorl %edi, %edi
cmpq %rcx, 0x20(%rsi)
setb %dil
cmovaeq %rsi, %rdx
movq 0x10(%rsi,%rdi,8), %rsi
testq %rsi, %rsi
jne 0x37b2
movq %r15, %rsi
cmpq %r15, %rdx
je 0x37dd
cmpq 0x20(%rdx), %rcx
cmovbq %r15, %rdx
movq %rdx, %rsi
cmpq %r15, %rsi
jne 0x37f3
movq %rax, %rdi
callq 0x21b0
cmpq %rbx, %rax
setne %bpl
jne 0x37a0
leaq 0x8(%rsp), %rdi
callq 0x4850
andb $0x1, %bpl
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3816
jmp 0x3816
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4850
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/kage08[P]RegexLibrary/Resource.cpp
// Function: addConcat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::set<char, std::less<char>, std::allocator<char>>)
string addConcat(string& regex,set<char> alphabet){
  if(regex=="%") return regex;
  string ans="";
  uint len=regex.length();
  for(uLong i=0;i<len;i++){
    if(alphabet.find(regex[i])!=alphabet.end() || regex[i]=='@' || regex[i]=='(' || regex[i]=='%'){
      if(i>0 && (regex[i-1]!='+' && regex[i-1]!='(')) ans.append(".");
    }
    ans.append(string(1,regex[i]));
  }
  return ans;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x384d(%rip), %rsi      # 0x7098
movq %r14, %rdi
callq 0x2060
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testl %eax, %eax
je 0x397d
movq %rcx, 0x8(%rsp)
leaq 0x3827(%rip), %rdx      # 0x7095
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x526e
movl 0x8(%r14), %ebp
testq %rbp, %rbp
je 0x398f
movq 0x10(%rsp), %rax
leaq 0x8(%rax), %r12
leaq 0x28(%rsp), %r13
xorl %r15d, %r15d
movq (%r14), %rax
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rdx
movq %r12, %rcx
testq %rdx, %rdx
je 0x38ca
movb (%rax,%r15), %sil
movq %r12, %rcx
xorl %edi, %edi
cmpb %sil, 0x20(%rdx)
setl %dil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x38b2
movq %r12, %rdx
cmpq %r12, %rcx
je 0x38e0
movb (%rax,%r15), %dl
cmpb 0x20(%rcx), %dl
cmovlq %r12, %rcx
movq %rcx, %rdx
cmpq %r12, %rdx
je 0x390b
testq %r15, %r15
je 0x392a
movzbl -0x1(%rax,%r15), %eax
cmpl $0x28, %eax
je 0x392a
cmpl $0x2b, %eax
je 0x392a
movq %rbx, %rdi
leaq 0x3796(%rip), %rsi      # 0x709a
callq 0x22a0
jmp 0x392a
movzbl (%rax,%r15), %ecx
cmpl $0x28, %ecx
je 0x38e5
cmpl $0x40, %ecx
je 0x38e5
cmpb $0x25, %cl
sete %cl
testq %r15, %r15
setne %dl
testb %cl, %dl
jne 0x38ea
movq (%r14), %rax
movsbl (%rax,%r15), %edx
movq %r13, 0x18(%rsp)
movl $0x1, %esi
leaq 0x18(%rsp), %rdi
callq 0x21c0
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x2070
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x396f
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2180
incq %r15
cmpq %rbp, %r15
jne 0x3897
jmp 0x398f
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x51de
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x39a3
movq %rax, %r14
jmp 0x39c2
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x39c2
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2180
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x39dc
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/chrislarson1[P]MVEE/include/utils.hpp
// Function: toStdVec(Eigen::Matrix<double, -1, 1, 0, -1, 1>&, double (*)(double))
std::vector<double> toStdVec(Eigen::VectorXd& fromX, double (*f)(double))
{
	std::vector<double> toX(fromX.size(), 0.);
	for (int i=0; i<fromX.size(); i++)
	{
		toX[i] = (*f)(fromX(i));
	}
	return toX;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0xf(%rsp), %rcx
callq 0x13160
cmpq $0x0, 0x8(%r15)
jle 0x135fe
xorl %r12d, %r12d
movq (%r15), %rax
movsd (%rax,%r12,8), %xmm0
callq *%r14
movq (%rbx), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
cmpq %r12, 0x8(%r15)
jg 0x135e0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x13624
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x12a90
movq %r14, %rdi
callq 0x13210
// File: /workspace/github_cpp_makefile_star2_O1/chrislarson1[P]MVEE/include/utils.hpp
// Function: toStdMat(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, double (*)(double))
std::vector<std::vector<double>> toStdMat(Eigen::MatrixXd& fromX, double (*f)(double))
{
	std::vector<std::vector<double>> 
	toX(fromX.rows(), std::vector<double>(fromX.cols(), 0.));
	for (int i=0; i<fromX.rows(); i++)
	{
		for (int j=0; j<fromX.cols(); j++)
		{
			toX[i][j] = (*f)(fromX(i, j));
		}
	}
	return toX;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r12
movq 0x10(%rsi), %rsi
leaq 0x20(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
callq 0x13160
leaq 0x8(%rsp), %rdx
leaq 0x6(%rsp), %rcx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x125d0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x13692
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x12a90
cmpq $0x0, 0x8(%r15)
jle 0x136e4
xorl %r12d, %r12d
cmpq $0x0, 0x10(%r15)
jle 0x136db
leaq (%r12,%r12,2), %r13
xorl %ebp, %ebp
movq 0x8(%r15), %rax
cmpq %r12, %rax
jle 0x136f6
imulq %rbp, %rax
shlq $0x3, %rax
addq (%r15), %rax
movsd (%rax,%r12,8), %xmm0
callq *%r14
movq (%rbx), %rax
movq (%rax,%r13,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
cmpq %rbp, 0x10(%r15)
jg 0x136a9
incq %r12
cmpq %r12, 0x8(%r15)
jg 0x1369c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22cdd(%rip), %rdi     # 0x363da
leaq 0x22be9(%rip), %rsi     # 0x362ed
leaq 0x22d04(%rip), %rcx     # 0x3640f
movl $0x16f, %edx            # imm = 0x16F
callq 0x126c0
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x13741
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x12a90
jmp 0x13741
movq %rax, %r14
jmp 0x13741
movq %rax, %r14
movq %rbx, %rdi
callq 0x12310
movq %r14, %rdi
callq 0x13210
// File: /workspace/github_cpp_makefile_star2_O1/chrislarson1[P]MVEE/src/mvee.cpp
// Function: mvee::Mvee::compute(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&, double, double)
void Mvee::compute(vector<vector<double>>& data, double eps, double lmcoeff)
{
    int rows = data.size();
    int cols = data[0].size();
    MatrixXd D(rows, cols);
    for (int i=0; i<rows; i++)
    {
        for (int j=0; j<cols; j++)
        {
            D(i, j) = data[i][j];
        }
    }
    khachiyan(D, eps, lmcoeff);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm1, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %r12
movq 0x8(%rax), %r15
subq (%rax), %r15
shrq $0x3, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movslq %r12d, %r8
movslq %r15d, %rcx
movq %rcx, %rax
orq %r8, %rax
js 0x150e2
movq %rsi, %r14
movq %rdi, %rbx
testl %r12d, %r12d
je 0x15014
testl %r15d, %r15d
je 0x15014
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
xorl %edx, %edx
idivq %rcx
cmpq %r8, %rax
jl 0x15101
movq %rcx, %rsi
imulq %r8, %rsi
movq %rsp, %rdi
movq %r8, %rdx
callq 0x12180
xorl %eax, %eax
testl %r12d, %r12d
cmovgl %r12d, %eax
jle 0x15097
movq 0x8(%rsp), %rcx
movl %r15d, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
leaq (,%rcx,8), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
testl %r15d, %r15d
jle 0x1508b
cmpq %r8, %rcx
jle 0x150c3
leaq (%r8,%r8,2), %r9
shlq $0x3, %r9
addq (%r14), %r9
movq (%rsp), %r10
addq %rdi, %r10
xorl %r11d, %r11d
cmpq %r11, 0x10(%rsp)
jle 0x150c3
movq (%r9), %r12
movsd (%r12,%r11,8), %xmm0
movsd %xmm0, (%r10)
incq %r11
addq %rsi, %r10
cmpq %r11, %rdx
jne 0x1506b
incq %r8
addq $0x8, %rdi
cmpq %rax, %r8
jne 0x1504c
movq %rsp, %rsi
movq %rbx, %rdi
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x12690
movq (%rsp), %rdi
callq 0x12c50
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x21310(%rip), %rdi     # 0x363da
leaq 0x2121c(%rip), %rsi     # 0x362ed
leaq 0x21337(%rip), %rcx     # 0x3640f
movl $0x16f, %edx            # imm = 0x16F
callq 0x126c0
leaq 0x213b6(%rip), %rdi     # 0x3649f
leaq 0x2153e(%rip), %rsi     # 0x3662e
leaq 0x2156c(%rip), %rcx     # 0x36663
movl $0x115, %edx            # imm = 0x115
callq 0x126c0
movl $0x8, %edi
callq 0x12510
movq 0x43ea6(%rip), %rcx     # 0x58fb8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x43eb0(%rip), %rsi     # 0x58fd0
movq 0x43e81(%rip), %rdx     # 0x58fa8
movq %rax, %rdi
callq 0x13170
jmp 0x15131
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x12c50
movq %rbx, %rdi
callq 0x13210
nop