LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/rfotino[P]consolite-emulator/src/processor.cpp
// Function: EmuProcessor::_setFlags(unsigned int const&, unsigned int const&, unsigned int const&, unsigned char const&)
void EmuProcessor::_setFlags(const uint32_t& dest,
                             const uint32_t& src,
                             const uint32_t& result,
                             const uint8_t& opcode) {
  // Overflow set if we added two positives and got a negative,
  // added two negatives and got a positive, subtracted a positive
  // from a negative and got a positive, or subtracted a negative
  // from a positive and got a negative
  if (OPCODE_ADD == opcode) {
    _overflowFlag =
      ((0x8000 & dest) && (0x8000 & src) && !(0x8000 & result)) ||
      (!(0x8000 & dest) && !(0x8000 & src) && (0x8000 & result));
  } else if (OPCODE_SUB == opcode || OPCODE_CMP == opcode) {
    _overflowFlag =
      ((0x8000 & dest) && !(0x8000 & src) && !(0x8000 & result)) ||
      (!(0x8000 & dest) && (0x8000 & src) && (0x8000 & result));
  } else {
    _overflowFlag = false;
  }
  // Carry set if c is too large to fit into 16 bits.
  _carryFlag = 0xffff < result;
  // Zero set if the result was zero.
  _zeroFlag = !(0xffff & result);
  // Sign flag set if the sign bit of the result is set.
  _signFlag = 0x8000 & result;
}

// Assembly:
movzbl (%r8), %eax
cmpl $0x14, %eax
je 0x4d78
cmpl $0xb, %eax
je 0x4d78
cmpl $0xa, %eax
jne 0x4da2
testb $-0x80, 0x1(%rsi)
movl (%rdx), %eax
jne 0x4d95
testw %ax, %ax
jns 0x4d85
jmp 0x4da2
testb $-0x80, 0x1(%rsi)
movl (%rdx), %eax
jne 0x4d8e
testw %ax, %ax
jns 0x4da2
movl (%rcx), %eax
shrl $0xf, %eax
andb $0x1, %al
jmp 0x4da4
testw %ax, %ax
jns 0x4d9a
jmp 0x4da2
testw %ax, %ax
jns 0x4da2
movb $0x1, %al
testb $-0x80, 0x1(%rcx)
je 0x4da4
xorl %eax, %eax
movb %al, 0x1002b(%rdi)
movl (%rcx), %eax
cmpl $0x10000, %eax          # imm = 0x10000
setae 0x1002c(%rdi)
testw %ax, %ax
sete 0x1002d(%rdi)
shrl $0xf, %eax
andb $0x1, %al
movb %al, 0x1002e(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/ef-gy[P]libefgy/include/ef.gy/test-case.h
// Function: main
int main(int argc, char **argv) {
  if (cli::options(argc, argv, false).matches == 0) {
    return run<function>() ? 0 : -1;
  } else {
    return 0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movl %edi, %ebp
callq 0x4a3c
callq 0x4ac2
leaq 0x18c86(%rip), %r8      # 0x1d6f8
leaq 0x18cb7(%rip), %r9      # 0x1d730
movq %rsp, %r15
xorl %ebx, %ebx
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x4fe8
movq (%r15), %r14
leaq 0x8(%rsp), %rdi
callq 0xa178
testq %r14, %r14
jne 0x4ab5
callq 0x4ad8
leaq 0x18cbd(%rip), %rdi     # 0x1d768
callq 0x5028
movzbl %al, %ebx
decl %ebx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ef-gy[P]libefgy/include/ef.gy/cli.h
// Function: efgy::cli::processor<efgy::cli::option, efgy::cli::hint>::apply(int, char**)
void apply(int argc, char *argv[]) {
    std::vector<std::string> args;
    for (int i = 0; i < argc; i++) {
      args.push_back(argv[i]);
    }
    apply(args);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
testl %esi, %esi
jle 0x10fd4
movq %rdx, %r14
movl %esi, %ebx
xorl %ebp, %ebp
leaq 0x38(%rsp), %r15
leaq 0xf(%rsp), %r12
leaq 0x10(%rsp), %r13
movq (%r14,%rbp,8), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x4e2a
movq %r13, %rdi
movq %r15, %rsi
callq 0x111fa
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x10fcc
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x4240
incq %rbp
cmpq %rbp, %rbx
jne 0x10f96
leaq 0x10(%rsp), %rsi
movq 0x30(%rsp), %rdi
callq 0x11034
leaq 0x10(%rsp), %rdi
callq 0xa178
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x10ffe
movq %rax, %rbx
jmp 0x11022
movq %rax, %rbx
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x11022
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x4240
leaq 0x10(%rsp), %rdi
callq 0xa178
movq %rbx, %rdi
callq 0x43b0
// File: /workspace/github_cpp_makefile_star2_O3/ahupowerdns[P]spamidea/getsender.cc
// Function: flattenDomain(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
string flattenDomain(const std::string& input, const vector<string>& repl)
{
  for(const auto& r: repl) {
    auto pos = input.find(r);
    if(pos != string::npos) {
      return "*."+r;
    }
  }
  return input;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %r15
movq 0x8(%rdx), %r12
cmpq %r12, %r15
je 0x4923
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x4510
cmpq $-0x1, %rax
jne 0x493e
addq $0x20, %r15
jmp 0x4901
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x6cce
jmp 0x4950
leaq 0x107b3(%rip), %rsi     # 0x150f8
movq %rbx, %rdi
movq %r15, %rdx
callq 0x5aa9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ahupowerdns[P]spamidea/getsender.cc
// Function: processReceived(_IO_FILE*)
void processReceived(FILE* fp)
{
  char line[512];
  std::string completeline;
  MailTreeNode* start = &g_mtn;
  while(fgets(line, sizeof(line)-1, fp)) {
    chomp(line);
    if(!*line)
      break;
    if(isspace(*line)) {
      *line=' ';
      completeline += line;
    }
    else {
      processLine(completeline, start);
      completeline=line;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x1919d(%rip), %rax     # 0x1e708
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
movq %rbx, %rdx
callq 0x44c0
testq %rax, %rax
je 0x561e
movl $0x2401, %ebp           # imm = 0x2401
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %r14, %rcx
movzbl (%rcx), %eax
cmpl $0xd, %eax
ja 0x5619
btl %eax, %ebp
jae 0x5619
movb $0x0, (%rcx)
movsbl 0x30(%rsp), %edi
testl %edi, %edi
je 0x561e
callq 0x4060
testl %eax, %eax
je 0x55d4
movb $0x20, 0x30(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x4590
jmp 0x55ff
movq %r15, %rdi
movq %r12, %rsi
callq 0x495f
movq 0x10(%rsp), %r13
movq %r14, %rdi
callq 0x4150
movq %r15, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x44a0
movq %r14, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
movq %rbx, %rdx
callq 0x44c0
movq %r14, %rcx
testq %rax, %rax
jne 0x55a0
jmp 0x561e
incq %rcx
jmp 0x55a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x563a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4320
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x566b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4320
movq %rbx, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O3/ahupowerdns[P]spamidea/getsender.cc
// Function: processFile(boost::filesystem::path const&)
void processFile(const boost::filesystem::path& p)
{
  FILE* fp = fopen(p.c_str(), "r");
  if(!fp) {
    cerr<<"Could not open " << p.string() << " for reading"<<endl;
    exit(EXIT_FAILURE);
  }
  processReceived(fp);
  fclose(fp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x10103(%rip), %rsi     # 0x15787
callq 0x43c0
testq %rax, %rax
je 0x56a8
movq %rax, %r14
movq %rax, %rdi
callq 0x553c
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4300
movq 0x18939(%rip), %rdi     # 0x1dfe8
leaq 0xfaa6(%rip), %rsi      # 0x1515c
callq 0x42f0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x42c0
leaq 0xfa9f(%rip), %rsi      # 0x1516c
movq %rax, %rdi
callq 0x42f0
movq %rax, %rdi
callq 0x4160
movl $0x1, %edi
callq 0x43d0
// File: /workspace/github_cpp_makefile_star2_O3/ahupowerdns[P]spamidea/getsender.cc
// Function: processDir(boost::filesystem::path const&)
void processDir(const boost::filesystem::path& p)
{
  for (auto& entry : boost::make_iterator_range(boost::filesystem::directory_iterator(p), {}))
    if (boost::filesystem::is_regular_file(entry))
      processFile(entry);
    else if (boost::filesystem::is_directory(entry))
      processDir(entry);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rsi
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x5ef4
movq $0x0, 0x18(%rsp)
movq (%rbx), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x5730
lock
incl (%rax)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
testq %rax, %rax
je 0x5738
lock
incl (%rax)
jmp 0x5738
movq $0x0, (%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
callq 0x14128
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x6784
leaq 0x8(%rsp), %rdi
callq 0x6784
leaq 0x18(%rsp), %rdi
callq 0x6784
leaq 0x20(%rsp), %rdi
callq 0x6784
movq 0x28(%rsp), %rax
movq %rax, (%rbx)
testq %rax, %rax
je 0x5783
lock
incl (%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x5795
lock
incl (%rax)
leaq 0x30(%rsp), %rbx
leaq 0x8(%rsp), %r14
movq %rsp, %r15
movq (%rsp), %r12
movq 0x10(%rsp), %rax
cmpq %rax, %r12
je 0x5827
testq %r12, %r12
je 0x57bd
cmpq $0x0, 0x38(%r12)
jne 0x57da
testq %rax, %rax
je 0x5827
cmpq $0x0, 0x38(%rax)
je 0x5827
testq %r12, %r12
je 0x5857
cmpq $0x0, 0x38(%r12)
je 0x5857
addq $0x8, %r12
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4550
cmpl $0x2, 0x8(%rsp)
jne 0x57fc
movq %r12, %rdi
callq 0x5673
jmp 0x5818
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4550
cmpl $0x3, 0x8(%rsp)
jne 0x5818
movq %r12, %rdi
callq 0x56e7
movq %r15, %rdi
xorl %esi, %esi
callq 0x4420
jmp 0x57a2
leaq 0x10(%rsp), %rdi
callq 0x6784
movq %rsp, %rdi
callq 0x6784
movq %rbx, %rdi
callq 0x6784
leaq 0x28(%rsp), %rdi
callq 0x6784
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xfa0d(%rip), %rdi      # 0x1526b
leaq 0xfa45(%rip), %rsi      # 0x152aa
leaq 0xfa6a(%rip), %rcx      # 0x152d6
movl $0x140, %edx            # imm = 0x140
callq 0x41f0
movq %rax, %r14
movq %rsp, %rdi
callq 0x6784
leaq 0x8(%rsp), %rdi
callq 0x6784
leaq 0x18(%rsp), %rdi
callq 0x6784
leaq 0x20(%rsp), %rdi
jmp 0x58c0
jmp 0x589e
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x6784
movq %rsp, %rdi
callq 0x6784
movq %rbx, %rdi
callq 0x6784
leaq 0x28(%rsp), %rdi
callq 0x6784
movq %r14, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O3/ahupowerdns[P]spamidea/getsender.cc
// Function: main
int main(int argc, char**argv)
{
  for(int n = 1 ; n < argc; ++n) {
    boost::filesystem::path p(argv[n]);
    if (boost::filesystem::exists(p)) {
      if (boost::filesystem::is_regular_file(p))
        processFile(p);
      else if (boost::filesystem::is_directory(p)) {
        processDir(p);
      }
    }
  }
  
  ofstream plot2("plot2.dot");
  plot2 << "digraph { " <<endl;
  g_mtn.emitLinks(plot2);
  plot2 << "}"<<endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
cmpl $0x2, %edi
jl 0x5978
movq %rsi, %rbx
leaq 0x18(%rsp), %r12
movl %edi, %r13d
movl $0x1, %ebp
leaq 0x8(%rsp), %r14
movq %rsp, %r15
movq (%rbx,%rbp,8), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x6276
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4480
cmpl $0x2, (%rsp)
jb 0x5959
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4480
cmpl $0x2, (%rsp)
jne 0x593e
movq %r14, %rdi
callq 0x5673
jmp 0x5959
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4480
cmpl $0x3, (%rsp)
jne 0x5959
movq %r14, %rdi
callq 0x56e7
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5970
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4320
incq %rbp
cmpq %rbp, %r13
jne 0x58ff
leaq 0xf7fa(%rip), %rsi      # 0x15179
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x10, %edx
callq 0x4360
leaq 0xf7eb(%rip), %rsi      # 0x15183
movl $0xa, %edx
movq %rbx, %rdi
callq 0x4390
movq 0x8(%rsp), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x42e0
movsbl %al, %esi
leaq 0x8(%rsp), %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4210
leaq 0x18d31(%rip), %rdi     # 0x1e708
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x5f24
leaq 0xf7a4(%rip), %rsi      # 0x1518e
leaq 0x8(%rsp), %rbx
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4390
movq 0x8(%rsp), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x42e0
movsbl %al, %esi
leaq 0x8(%rsp), %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4210
movq 0x18562(%rip), %rax     # 0x1df90
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x4290
leaq 0x100(%rsp), %rdi
callq 0x40f0
xorl %eax, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4470
jmp 0x5a96
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5a96
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4320
movq %rbx, %rdi
callq 0x4520
// File: /workspace/github_cpp_makefile_star2_O3/NathanWine[P]2048-AI-Solvers/src/MonteCarlo.cpp
// Function: monteCarloSolve(int, int, int, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
int monteCarloSolve(int n, int runs, int display_level,
    std::vector<int> &scores, std::vector<int> &highest_tiles) {

    int successes = 0;
    for (int i = 0; i < n; ++i) {
        std::pair<int, int> result = monteCarloSimulateGame(runs, display_level, Game());
        if (result.first >= WIN) {
            successes++;
        }
        highest_tiles.push_back(result.first);
        scores.push_back(result.second);
    }
    return successes;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, 0x14(%rsp)
movl %esi, 0x10(%rsp)
testl %edi, %edi
jle 0x2c97
movq %r8, %rbx
movq %rcx, %r14
movl %edi, %r12d
xorl %r13d, %r13d
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x2df6
movl 0x10(%rsp), %edi
movl 0x14(%rsp), %esi
movq %r15, %rdx
callq 0x2977
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2da2
movl 0x8(%rsp), %eax
xorl %r15d, %r15d
cmpl $0x800, %eax            # imm = 0x800
setge %bpl
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2c52
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2c5f
movq %rbx, %rdi
leaq 0x8(%rsp), %rdx
callq 0x3560
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x2c79
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0x2c86
movq %r14, %rdi
leaq 0xc(%rsp), %rdx
callq 0x3560
movb %bpl, %r15b
addl %r15d, %r13d
decl %r12d
jne 0x2c00
jmp 0x2c9a
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2da2
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/NathanWine[P]2048-AI-Solvers/include/Game.hpp
// Function: Game::Game()
Game() : score(0), state{{0, 0, 0, 0}, 
                                 {0, 0, 0, 0}, 
                                 {0, 0, 0, 0}, 
                                 {0, 0, 0, 0}} {
            addNew();
            addNew();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
movl $0x0, (%rdi)
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rcx
movl $0x4, %edx
movq %r14, %rdi
callq 0x2d5c
leaq 0x28(%rsp), %r15
leaq 0x90(%rsp), %rsi
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
leaq 0xe(%rsp), %rcx
movl $0x4, %edx
movq %r15, %rdi
callq 0x2d5c
leaq 0x40(%rsp), %r15
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0xd(%rsp), %rcx
movl $0x4, %edx
movq %r15, %rdi
callq 0x2d5c
leaq 0x58(%rsp), %r15
leaq 0x70(%rsp), %rsi
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
leaq 0xc(%rsp), %rcx
movl $0x4, %edx
movq %r15, %rdi
callq 0x2d5c
leaq 0x8(%rbx), %r14
leaq 0x10(%rsp), %rsi
leaq 0xb(%rsp), %rcx
movl $0x4, %edx
movq %r14, %rdi
callq 0x2f5e
movl $0x60, %r15d
movq -0x8(%rsp,%r15), %rdi
testq %rdi, %rdi
je 0x2ed4
movq 0x8(%rsp,%r15), %rsi
subq %rdi, %rsi
callq 0x21a0
addq $-0x18, %r15
jne 0x2ebd
movq %rbx, %rdi
callq 0x60a6
movq %rbx, %rdi
callq 0x60a6
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x60, %r14d
movq -0x8(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x2f17
movq 0x8(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x21a0
addq $-0x18, %r14
jne 0x2f00
jmp 0x2f56
jmp 0x2f23
jmp 0x2f23
movq %rax, %rbx
movq -0x18(%r15), %rdi
testq %rdi, %rdi
je 0x2f3b
movq -0x8(%r15), %rsi
subq %rdi, %rsi
callq 0x21a0
addq $-0x18, %r15
cmpq %r14, %r15
jne 0x2f26
jmp 0x2f56
movq %rax, %rbx
jmp 0x2f56
movq %rax, %rbx
movq %r14, %rdi
callq 0x2da2
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/NathanWine[P]2048-AI-Solvers/src/Minimax.cpp
// Function: minimaxSolve(int, int, int, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
int minimaxSolve(int n, int depth, int display_level, 
    std::vector<int> &scores, std::vector<int> &highest_tiles) {

    int successes = 0;
    for (int i = 0; i < n; ++i) {
        std::pair<int, int> result = minimaxSearch(depth, display_level, Game());
        if (result.first >= WIN) {
            successes++;
        }
        highest_tiles.push_back(result.first);
        scores.push_back(result.second);
    }
    return successes;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, 0x14(%rsp)
movl %esi, 0x10(%rsp)
testl %edi, %edi
jle 0x3d31
movq %r8, %rbx
movq %rcx, %r14
movl %edi, %r12d
xorl %r13d, %r13d
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x2df6
movl 0x10(%rsp), %edi
movl 0x14(%rsp), %esi
movq %r15, %rdx
callq 0x3820
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2da2
movl 0x8(%rsp), %eax
xorl %r15d, %r15d
cmpl $0x800, %eax            # imm = 0x800
setge %bpl
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3cec
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3cf9
movq %rbx, %rdi
leaq 0x8(%rsp), %rdx
callq 0x3560
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x3d13
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0x3d20
movq %r14, %rdi
leaq 0xc(%rsp), %rdx
callq 0x3560
movb %bpl, %r15b
addl %r15d, %r13d
decl %r12d
jne 0x3c9a
jmp 0x3d34
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2da2
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/NathanWine[P]2048-AI-Solvers/src/Main.cpp
// Function: CmdParser::getCmdOption(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const std::string& getCmdOption(const std::string &opt) const {
            std::vector<std::string>::const_iterator itr;
            itr =  std::find(cmds.begin(), cmds.end(), opt);
            if (itr != cmds.end() && ++itr != cmds.end()){
                return *itr;
            }
            static const std::string empty_string("");
            return empty_string;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rsi
callq 0x57e5
movq %rax, %rbx
movq 0x8(%r14), %rax
cmpq %rax, %rbx
setne %cl
addq $0x20, %rbx
cmpq %rax, %rbx
setne %al
testb %al, %cl
jne 0x541e
movb 0x7da5(%rip), %al       # 0xd1b8
leaq 0x7d7e(%rip), %rbx      # 0xd198
testb %al, %al
je 0x5429
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x7d88(%rip), %rdi      # 0xd1b8
callq 0x22d0
testl %eax, %eax
je 0x541e
leaq 0x7d68(%rip), %rax      # 0xd1a8
movq %rax, 0x7d51(%rip)      # 0xd198
leaq 0x7d4a(%rip), %rbx      # 0xd198
leaq 0x3c66(%rip), %rdx      # 0x90bb
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x5a1a
movq 0x7b61(%rip), %rdi      # 0xcfc8
leaq 0x7d12(%rip), %rdx      # 0xd180
movq %rbx, %rsi
callq 0x2160
leaq 0x7d3b(%rip), %rdi      # 0xd1b8
callq 0x2100
jmp 0x541e
movq %rax, %rbx
leaq 0x7d2a(%rip), %rdi      # 0xd1b8
callq 0x20f0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/NathanWine[P]2048-AI-Solvers/src/Game.cpp
// Function: numDigits(int)
int numDigits(int32_t x)
{
    if (x >= 10000) {
        if (x >= 10000000) {
            if (x >= 100000000) {
                if (x >= 1000000000)
                    return 10;
                return 9;
            }
            return 8;
        }
        if (x >= 100000) {
            if (x >= 1000000)
                return 7;
            return 6;
        }
        return 5;
    }
    if (x >= 100) {
        if (x >= 1000)
            return 4;
        return 3;
    }
    if (x >= 10)
        return 2;
    return 1;
}

// Assembly:
cmpl $0x2710, %edi           # imm = 0x2710
jl 0x606d
cmpl $0x989680, %edi         # imm = 0x989680
jb 0x607f
movl $0x8, %eax
cmpl $0x5f5e100, %edi        # imm = 0x5F5E100
jb 0x60a5
cmpl $0x3b9aca00, %edi       # imm = 0x3B9ACA00
movl $0x9, %eax
jmp 0x6097
cmpl $0x64, %edi
jl 0x609b
cmpl $0x3e8, %edi            # imm = 0x3E8
movl $0x3, %eax
jmp 0x6097
movl $0x5, %eax
cmpl $0x186a0, %edi          # imm = 0x186A0
jb 0x60a5
cmpl $0xf4240, %edi          # imm = 0xF4240
movl $0x6, %eax
sbbl $-0x1, %eax
retq
xorl %eax, %eax
cmpl $0xa, %edi
setge %al
incl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/NathanWine[P]2048-AI-Solvers/src/Game.cpp
// Function: Game::addNew()
void Game::addNew() {
    // Create vector of empty tiles
    std::vector<std::pair<int, int>> empty_tiles;
    for (int i = 0; i < DIM; ++i) {
        for (int j = 0; j < DIM; ++j) {
            if (state[i][j] == 0) {
                empty_tiles.push_back(std::pair<int, int>(i, j));
            }
        }
    }

    int size = empty_tiles.size();
    if (size > 0) {
        // Get random empty tile coordinates
        std::pair<int, int> choice = empty_tiles[DISTS[size-1](rng)];

        // Generating a random value of 2 or 4 (weighted probability)
        if (DISTS[9](rng) > 0) {
            state[choice.first][choice.second] = 2;
        }
        else {
            state[choice.first][choice.second] = 4;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
leaq (%r12,%r12,2), %r13
xorl %ebp, %ebp
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rax
cmpl $0x0, (%rax,%rbp,4)
jne 0x60fb
movl %r12d, 0x8(%rsp)
movl %ebp, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x78d8
incq %rbp
cmpq $0x4, %rbp
jne 0x60d9
incq %r12
cmpq $0x4, %r12
jne 0x60d3
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
sarq $0x3, %rax
testl %eax, %eax
jle 0x617f
decl %eax
leaq 0x97b8(%rip), %rcx      # 0xf8e0
leaq (%rcx,%rax,8), %rdi
leaq 0x841d(%rip), %rsi      # 0xe550
movq %rdi, %rdx
callq 0x3302
cltq
movq 0x10(%rsp), %rcx
movslq (%rcx,%rax,8), %r15
movslq 0x4(%rcx,%rax,8), %r14
leaq 0x83fe(%rip), %rsi      # 0xe550
leaq 0x97cf(%rip), %rdi      # 0xf928
movq %rdi, %rdx
callq 0x3302
xorl %ecx, %ecx
testl %eax, %eax
setle %cl
movq 0x8(%rbx), %rax
leaq (%r15,%r15,2), %rdx
movq (%rax,%rdx,8), %rax
leal 0x2(,%rcx,2), %ecx
movl %ecx, (%rax,%r14,4)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x6196
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x61a7
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x61c1
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/NathanWine[P]2048-AI-Solvers/src/Game.cpp
// Function: Game::canContinue() const
bool Game::canContinue() const {
    for (int i = 0; i < DIM; ++i) {
        for (int j = 0; j < DIM; ++j) {
            if (state[i][j] == 0)
                return true;
            if ((i < (DIM-1) && state[i][j] == state[i + 1][j]) || 
                (j < (DIM-1) && state[i][j] == state[i][j + 1]))    // If adj. hor/ver match
                return true;
        }
    }
    return false;
}

// Assembly:
movq 0x8(%rdi), %rcx
leaq 0x18(%rcx), %rdx
movb $0x1, %al
xorl %esi, %esi
leaq (,%rsi,8), %rdi
leaq (%rdi,%rdi,2), %rdi
movq (%rcx,%rdi), %r8
movl (%r8), %r9d
testl %r9d, %r9d
je 0x6235
addq %rdx, %rdi
xorl %r10d, %r10d
cmpq $0x3, %rsi
je 0x6203
movq (%rdi), %r11
cmpl (%r11,%r10,4), %r9d
je 0x6235
cmpq $0x3, %r10
je 0x621f
cmpl 0x4(%r8,%r10,4), %r9d
je 0x6235
movl 0x4(%r8,%r10,4), %r9d
incq %r10
testl %r9d, %r9d
jne 0x61f4
jmp 0x6235
cmpq $0x3, %rsi
leaq 0x1(%rsi), %rdi
setb %al
movq %rdi, %rsi
cmpq $0x4, %rdi
jne 0x61d6
xorl %eax, %eax
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/NathanWine[P]2048-AI-Solvers/src/Game.cpp
// Function: Game::up(bool)
void Game::up(bool peak) {
    board prev_state = state;
    mergeUp();
    compressUp(peak);
    if (state != prev_state && !peak) {
        addNew();
    }
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rdi), %rsi
movq %rsp, %rdi
callq 0x2cc2
movq %rbx, %rdi
callq 0x689c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x69c6
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
movq %rsi, %rax
subq %rdi, %rax
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
subq %rdx, %rcx
cmpq %rcx, %rax
jne 0x6591
callq 0x329a
jmp 0x6593
xorl %eax, %eax
orb %al, %bpl
jne 0x65a0
movq %rbx, %rdi
callq 0x60a6
movq %rsp, %rdi
callq 0x2da2
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2da2
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/NathanWine[P]2048-AI-Solvers/src/Game.cpp
// Function: Game::mergeUp()
void Game::mergeUp() {
    for (int col = 0; col < DIM; ++col) {
        std::vector<int> merged_column;
        for (int i = 0; i < DIM; ++i) {
            if (state[i][col] != 0) {
                merged_column.push_back(state[i][col]);
            }            
        }
        while (merged_column.size() < DIM) {
            merged_column.push_back(0);
        }
        for (int i = 0; i < DIM; ++i) {
            state[i][col] = merged_column[i];
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorl %r12d, %r12d
movq %rsp, %r14
leaq 0x1c(%rsp), %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movq (%rax,%r13), %rax
movl (%rax,%r12,4), %ecx
testl %ecx, %ecx
je 0x68ff
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x68f3
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x68ff
leaq (%rax,%r12,4), %rdx
movq %r14, %rdi
callq 0x3560
addq $0x18, %r13
cmpq $0x60, %r13
jne 0x68ca
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rsi, %rax
subq %rdi, %rax
cmpq $0xf, %rax
ja 0x695e
movl $0x0, 0x1c(%rsp)
cmpq 0x10(%rsp), %rsi
je 0x693e
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x6952
movq %r14, %rdi
movq %r15, %rdx
callq 0x80fe
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rsi, %rax
subq %rdi, %rax
cmpq $0x10, %rax
jb 0x691e
movq 0x8(%rbx), %rax
xorl %ecx, %ecx
movl (%rdi,%rcx,4), %edx
movq (%rax), %rsi
movl %edx, (%rsi,%r12,4)
incq %rcx
addq $0x18, %rax
cmpq $0x4, %rcx
jne 0x6964
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
incq %r12
cmpq $0x4, %r12
jne 0x68b7
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x69a5
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x69be
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/NathanWine[P]2048-AI-Solvers/src/Game.cpp
// Function: Game::hamburgerFlip()
void Game::hamburgerFlip() {
    board flipped_state = {{}, {}, {}, {}};
    for (int row = (DIM-1), i = 0; row >= 0; --row, ++i) {
        flipped_state[i] = state[row];
    }
    state = flipped_state;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
callq 0x2f5e
movl $0x60, %r14d
movq 0x8(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x6de7
movq 0x18(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x21a0
addq $-0x18, %r14
jne 0x6dd0
addq $0x8, %rbx
movl $0x48, %r14d
xorl %r15d, %r15d
movq (%rbx), %rsi
addq %r14, %rsi
movq 0x8(%rsp), %rdi
addq %r15, %rdi
callq 0x75ea
addq $-0x18, %r14
addq $0x18, %r15
cmpq $-0x18, %r14
jne 0x6dfa
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x76ce
leaq 0x8(%rsp), %rdi
callq 0x2da2
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x6e58
leaq 0x80(%rsp), %rdi
movq %rax, %rbx
leaq 0x20(%rsp), %rsi
callq 0x23cd
jmp 0x6e65
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2da2
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/NathanWine[P]2048-AI-Solvers/src/Game.cpp
// Function: Game::transpose()
void Game::transpose() {
    board transposed_state = {{0,0,0,0}, {0,0,0,0}, {0,0,0,0}, {0,0,0,0}};
    for (int i = 0; i < DIM; ++i) {
        for (int j = 0; j < DIM; ++j) {
            transposed_state[i][j] = state[j][i];
        }
    }
    state = transposed_state;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0xb0(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x20(%rsp), %r14
leaq 0x7(%rsp), %rcx
movl $0x4, %edx
movq %r14, %rdi
callq 0x2d5c
leaq 0x38(%rsp), %r15
leaq 0xa0(%rsp), %rsi
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
leaq 0x6(%rsp), %rcx
movl $0x4, %edx
movq %r15, %rdi
callq 0x2d5c
leaq 0x50(%rsp), %r15
xorps %xmm0, %xmm0
leaq 0x90(%rsp), %rsi
movaps %xmm0, (%rsi)
leaq 0x5(%rsp), %rcx
movl $0x4, %edx
movq %r15, %rdi
callq 0x2d5c
leaq 0x68(%rsp), %r15
leaq 0x80(%rsp), %rsi
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
leaq 0x4(%rsp), %rcx
movl $0x4, %edx
movq %r15, %rdi
callq 0x2d5c
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x3(%rsp), %rcx
movl $0x4, %edx
callq 0x2f5e
movl $0x60, %r14d
movq 0x8(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x6f47
movq 0x18(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x21a0
addq $-0x18, %r14
jne 0x6f30
movq 0x8(%rbx), %rax
addq $0x8, %rbx
movq 0x8(%rsp), %rcx
xorl %edx, %edx
leaq (%rdx,%rdx,2), %rsi
movq (%rcx,%rsi,8), %rsi
movq %rax, %rdi
xorl %r8d, %r8d
movq (%rdi), %r9
movl (%r9,%rdx,4), %r9d
movl %r9d, (%rsi,%r8,4)
incq %r8
addq $0x18, %rdi
cmpq $0x4, %r8
jne 0x6f6a
incq %rdx
cmpq $0x4, %rdx
jne 0x6f5c
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x76ce
leaq 0x8(%rsp), %rdi
callq 0x2da2
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2da2
jmp 0x7010
movq %rax, %rbx
movl $0x60, %r14d
movq 0x8(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x6fde
movq 0x18(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x21a0
addq $-0x18, %r14
jne 0x6fc7
jmp 0x7010
jmp 0x6fea
jmp 0x6fea
movq %rax, %rbx
movq -0x18(%r15), %rdi
testq %rdi, %rdi
je 0x7002
movq -0x8(%r15), %rsi
subq %rdi, %rsi
callq 0x21a0
addq $-0x18, %r15
cmpq %r14, %r15
jne 0x6fed
jmp 0x7010
movq %rax, %rbx
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/NathanWine[P]2048-AI-Solvers/src/Game.cpp
// Function: Game::getHighestTile() const
int Game::getHighestTile() const {
    int highest_tile = 2;
    for (int i = 0; i < DIM; ++i) {
        for (int j = 0; j < DIM; ++j) {
            if (state[i][j] > highest_tile) {
                highest_tile = state[i][j];
            }
        }
    }
    return highest_tile;
}

// Assembly:
movq 0x8(%rdi), %rcx
movl $0x2, %eax
xorl %edx, %edx
movq (%rcx,%rdx), %rsi
movd %eax, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqu (%rsi), %xmm1
movdqa %xmm1, %xmm2
pcmpgtd %xmm0, %xmm2
pand %xmm2, %xmm1
pandn %xmm0, %xmm2
por %xmm1, %xmm2
pshufd $0xee, %xmm2, %xmm0     # xmm0 = xmm2[2,3,2,3]
movdqa %xmm2, %xmm1
pcmpgtd %xmm0, %xmm1
pand %xmm1, %xmm2
pandn %xmm0, %xmm1
por %xmm2, %xmm1
pshufd $0x55, %xmm1, %xmm0     # xmm0 = xmm1[1,1,1,1]
movdqa %xmm1, %xmm2
pcmpgtd %xmm0, %xmm2
pand %xmm2, %xmm1
pandn %xmm0, %xmm2
por %xmm1, %xmm2
movd %xmm2, %eax
addq $0x18, %rdx
cmpq $0x60, %rdx
jne 0x7023
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/NathanWine[P]2048-AI-Solvers/src/Game.cpp
// Function: Game::getNumberEmpty(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&)
int Game::getNumberEmpty(const board &game_state) {
    int sum = 0;
    for (int i = 0; i < DIM; ++i) {
        for (int j = 0; j < DIM; ++j) {
            if (game_state[i][j] == 0) {
                sum += 1;
            }
        }
    }
    return sum;
}

// Assembly:
movq (%rdi), %rcx
xorl %edx, %edx
pxor %xmm0, %xmm0
xorl %eax, %eax
movq (%rcx,%rdx), %rsi
movd %eax, %xmm1
movdqu (%rsi), %xmm2
pcmpeqd %xmm0, %xmm2
psubd %xmm2, %xmm1
pshufd $0xee, %xmm1, %xmm2     # xmm2 = xmm1[2,3,2,3]
paddd %xmm1, %xmm2
pshufd $0x55, %xmm2, %xmm1     # xmm1 = xmm2[1,1,1,1]
paddd %xmm2, %xmm1
movd %xmm1, %eax
addq $0x18, %rdx
cmpq $0x60, %rdx
jne 0x7095
retq
// File: /workspace/github_cpp_makefile_star2_O3/NathanWine[P]2048-AI-Solvers/src/Expectimax.cpp
// Function: expectimaxSolve(int, int, int, std::vector<int, std::allocator<int>>*, std::vector<int, std::allocator<int>>*)
int expectimaxSolve(int n, int depth, int display_level, 
    std::vector<int> *scores, std::vector<int> *highest_tiles) {

    int successes = 0;
    for (int i = 0; i < n; ++i) {
        std::pair<int, int> result = expectimaxSearch(depth, display_level, Game());
        if (result.first >= WIN) {
            successes++;
        }
        (*highest_tiles).push_back(result.first);
        (*scores).push_back(result.second);
    }
    return successes;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, 0x14(%rsp)
movl %esi, 0x10(%rsp)
testl %edi, %edi
jle 0x8cd6
movq %r8, %rbx
movq %rcx, %r14
movl %edi, %r12d
xorl %r13d, %r13d
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x2df6
movl 0x10(%rsp), %edi
movl 0x14(%rsp), %esi
movq %r15, %rdx
callq 0x873f
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2da2
movl 0x8(%rsp), %eax
xorl %r15d, %r15d
cmpl $0x800, %eax            # imm = 0x800
setge %bpl
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x8c91
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x8c9e
movq %rbx, %rdi
leaq 0x8(%rsp), %rdx
callq 0x3560
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x8cb8
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0x8cc5
movq %r14, %rdi
leaq 0xc(%rsp), %rdx
callq 0x3560
movb %bpl, %r15b
addl %r15d, %r13d
decl %r12d
jne 0x8c3f
jmp 0x8cd9
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2da2
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/NathanWine[P]2048-AI-Solvers/src/Heuristics.cpp
// Function: Heuristics::get_snake(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&)
float Heuristics::get_snake(const board &state) {        // Perhaps this should be normalized and multiplied by a weight instead? Becomes the only factor at high value tiles
    float snake_total = 0.0;
    for (int i = 0; i < DIM; ++i) {
        for (int j = 0; j < DIM; ++j) {
            snake_total += state[i][j] * snake_weights[i][j];
        }
    }
    return snake_total;
}

// Assembly:
movq (%rdi), %rax
xorps %xmm0, %xmm0
leaq 0x847(%rip), %rcx       # 0x96a0
xorl %edx, %edx
leaq (%rdx,%rdx,2), %rsi
movq (%rax,%rsi,8), %rsi
xorl %edi, %edi
xorps %xmm1, %xmm1
cvtsi2ssl (%rsi,%rdi,4), %xmm1
mulss (%rcx,%rdi,4), %xmm1
addss %xmm1, %xmm0
incq %rdi
cmpq $0x4, %rdi
jne 0x8e65
incq %rdx
addq $0x10, %rcx
cmpq $0x4, %rdx
jne 0x8e5b
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/units/redirect/redirect_cli.c
// Function: test_hash
void test_hash()
{
  rdint_t in_n = 250 * 1000 * 1000;
  double *in_v = malloc(in_n * sizeof(*in_v));
  vector_init(in_v, in_n, 1, 1.0, NAN);

  rdint_t size = in_n * sizeof(*in_v);

  double t = z_time_wtime();
  redirect_call_hash_param_array_double(in_v, in_n);
  t = z_time_wtime() - t;

  printf("test_hash: size: %" rdint_fmt ", time: %f, rate: %f\n", size, t, (double) size / t * 1e-6);

  free(in_v);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl $0x77359400, %edi       # imm = 0x77359400
callq 0xb6f0
movq %rax, %rbx
movsd 0x5c5b0(%rip), %xmm0    # 0x69008
movsd 0x5c5b0(%rip), %xmm1    # 0x69010
movl $0xee6b280, %esi        # imm = 0xEE6B280
movl $0x1, %edx
movq %rax, %rdi
callq 0xda80
leaq 0x8(%rsp), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0xb480
xorps %xmm0, %xmm0
cvtsi2sdq (%r14), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdq 0x8(%r14), %xmm1
mulsd 0x5c57b(%rip), %xmm1    # 0x69018
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movl $0xee6b280, %esi        # imm = 0xEE6B280
movq %rbx, %rdi
callq 0x1196e
leaq 0x8(%rsp), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0xb480
xorps %xmm1, %xmm1
cvtsi2sdq (%r14), %xmm1
xorps %xmm0, %xmm0
cvtsi2sdq 0x8(%r14), %xmm0
mulsd 0x5c53a(%rip), %xmm0    # 0x69018
addsd %xmm1, %xmm0
subsd (%rsp), %xmm0
movsd 0x5c531(%rip), %xmm1    # 0x69020
divsd %xmm0, %xmm1
mulsd 0x5c52d(%rip), %xmm1    # 0x69028
leaq 0x5c546(%rip), %rdi     # 0x69048
movl $0x77359400, %esi       # imm = 0x77359400
movb $0x2, %al
callq 0xb080
movq %rbx, %rdi
callq 0xb650
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/units/redirect/redirect_cli.c
// Function: test_result
void test_result(const char *uri)
{
  redirect_call_t rc;

  redirect_call_create_scdc(&rc, "result", uri);

  redirect_call_execute(&rc);

  TRACE_F("result: '%s'", redirect_call_get_result_str(&rc, NULL, 0));

  redirect_call_destroy_scdc(&rc);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xbb0, %rsp            # imm = 0xBB0
movq %rdi, %rdx
leaq 0x5fad4(%rip), %rsi     # 0x6c608
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xf8fc
movq %rbx, %rdi
callq 0xfa4a
movq 0x7f452(%rip), %r15     # 0x8bfa0
movq (%r15), %rdi
leaq 0x5c51a(%rip), %rsi     # 0x69072
leaq 0x5c526(%rip), %rdx     # 0x69085
xorl %eax, %eax
callq 0xb7a0
movq (%r15), %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10a7d
leaq 0x5cbf5(%rip), %rsi     # 0x69771
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb7a0
movq (%r15), %rsi
movl $0xa, %edi
callq 0xb690
movq %rbx, %rdi
callq 0xf9c1
addq $0xbb0, %rsp            # imm = 0xBB0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/units/redirect/redirect_cli.c
// Function: test_param_matrix
void test_param_matrix(const char *uri)
{
  redirect_call_t rc;

  redirect_call_create_scdc(&rc, "param_matrix", uri);

  /* double ohne/mit stride */

  redirect_call_execute(&rc);

  TRACE_F("result: '%s'", redirect_call_get_result_str(&rc, NULL, 0));

  redirect_call_destroy_scdc(&rc);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xbb0, %rsp            # imm = 0xBB0
movq %rdi, %rdx
leaq 0x5bc5e(%rip), %rsi     # 0x69582
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xf8fc
movq %rbx, %rdi
callq 0xfa4a
movq 0x7e662(%rip), %r15     # 0x8bfa0
movq (%r15), %rdi
leaq 0x5b72a(%rip), %rsi     # 0x69072
leaq 0x5ba1a(%rip), %rdx     # 0x69369
xorl %eax, %eax
callq 0xb7a0
movq (%r15), %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10a7d
leaq 0x5be05(%rip), %rsi     # 0x69771
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb7a0
movq (%r15), %rsi
movl $0xa, %edi
callq 0xb690
movq %rbx, %rdi
callq 0xf9c1
addq $0xbb0, %rsp            # imm = 0xBB0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/units/redirect/redirect_cli.c
// Function: main
int main(int argc, char *argv[])
{
  scdc_init(SCDC_INIT_DEFAULT);

  TRACE_F("dataprov open");
  scdc_dataprov_t dp = scdc_dataprov_open(REDIRECT_TEST_SCDC_PATH, "hook", &redirect_test_hook);

#if 1
  const char *uri = "scdc:/" REDIRECT_TEST_SCDC_PATH;
#else
  const char *uri = "scdc+uds://redirect/" REDIRECT_TEST_SCDC_PATH;
#endif

#if TEST_HASH
  test_hash();
#endif

#if TEST_RESULT
  test_result(uri);
#endif

#if TEST_CONF
  test_conf(uri);
#endif

#if TEST_CACHE && REDIRECT_CALL_PARAMS_CACHE
  test_cache(uri);
#endif

#if TEST_PARAM_ARRAY
  test_param_array(uri);
#endif

#if TEST_PARAM_VECTOR
  test_param_vector(uri);
#endif

#if TEST_PARAM_MATRIX
  test_param_matrix(uri);
#endif

  TRACE_F("dataprov close");
  scdc_dataprov_close(dp);

  scdc_release();

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x5db83(%rip), %rdi     # 0x6b52d
xorl %eax, %eax
callq 0x190e1
movq 0x7e5e8(%rip), %r12     # 0x8bfa0
movq (%r12), %rdi
leaq 0x5b6af(%rip), %rbx     # 0x69072
leaq 0x5b9b1(%rip), %r14     # 0x6937b
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rcx
leaq 0x5b99e(%rip), %rdi     # 0x69380
movl $0xd, %esi
movl $0x1, %edx
callq 0xba90
movq (%r12), %rsi
movl $0xa, %edi
callq 0xb690
leaq 0x5b98e(%rip), %rdi     # 0x69394
leaq 0x5ef03(%rip), %rsi     # 0x6c910
leaq 0x7c1e4(%rip), %rdx     # 0x89bf8
xorl %eax, %eax
callq 0x1949b
movq %rax, %r15
leaq 0x5b969(%rip), %rdi     # 0x6938e
callq 0xd394
movq (%r12), %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rcx
leaq 0x5b957(%rip), %rdi     # 0x6939d
movl $0xe, %esi
movl $0x1, %edx
callq 0xba90
movq (%r12), %rsi
movl $0xa, %edi
callq 0xb690
movq %r15, %rdi
callq 0x19596
callq 0x191e2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/units/redirect/redirect_common.c
// Function: vector_init
void vector_init(double *v, rdint_t n, rdint_t inc, double xv, double xn)
{
  int i, j;

  for (i = 0; i < n; ++i)
  {
    v[i * inc + 0] = xv;
    if (i + 1 == n) break;
    for (j = 1; j < inc; ++j) v[i * inc + j] = xn;
  }
}

// Assembly:
testq %rsi, %rsi
jle 0xdb68
movsd %xmm0, (%rdi)
cmpq $0x1, %rsi
je 0xdb68
movabsq $0x7ffffffffffffffe, %rax # imm = 0x7FFFFFFFFFFFFFFE
andq %rdx, %rax
leaq -0x2(%rdx), %rcx
movq %rcx, %xmm2
pshufd $0x44, %xmm2, %xmm2     # xmm2 = xmm2[0,1,0,1]
leaq (,%rdx,8), %rcx
movl $0x1, %r8d
movdqa 0x5b8e8(%rip), %xmm3    # 0x693b0
movdqa 0x5b8f0(%rip), %xmm4    # 0x693c0
pxor %xmm4, %xmm2
pcmpeqd %xmm5, %xmm5
movq %rdi, %r9
cmpq $0x2, %rdx
jl 0xdb4c
xorl %r10d, %r10d
movq %r10, %xmm6
pshufd $0x44, %xmm6, %xmm6     # xmm6 = xmm6[0,1,0,1]
por %xmm3, %xmm6
pxor %xmm4, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm2, %xmm7
pcmpeqd %xmm2, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %r11d
notl %r11d
testb $0x1, %r11b
je 0xdb2c
movsd %xmm1, 0x8(%r9,%r10,8)
pxor %xmm5, %xmm6
pextrw $0x4, %xmm6, %r11d
testb $0x1, %r11b
je 0xdb43
movsd %xmm1, 0x10(%r9,%r10,8)
addq $0x2, %r10
cmpq %r10, %rax
jne 0xdae4
movq %r8, %r10
imulq %rdx, %r10
movsd %xmm0, (%rdi,%r10,8)
incq %r8
addq %rcx, %r9
cmpq %rsi, %r8
jne 0xdadb
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/units/redirect/redirect_test.c
// Function: redirect_test_open
void *redirect_test_open(const char *conf, va_list ap)
{
  TRACE_F("conf: '%s'", conf);

  redirect_call_t *rc = malloc(sizeof(redirect_call_t)
#if REDIRECT_CALL_PARAMS_CACHE
    + sizeof(redirect_cache_t)
#endif
    );

#if REDIRECT_CALL_PARAMS_CACHE
  redirect_cache_t *rch = (redirect_cache_t *) (rc + 1);

  redirect_cache_init(rch);
#endif

  TRACE_F("return: %p", rc);

  return rc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x7e422(%rip), %r12     # 0x8bfa0
movq (%r12), %rdi
leaq 0x5b867(%rip), %rbx     # 0x693f0
leaq 0x5b874(%rip), %r14     # 0x69404
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rdi
leaq 0x5b86f(%rip), %rsi     # 0x69417
movq %r15, %rdx
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rsi
movl $0xa, %edi
callq 0xb690
movl $0x1050, %edi           # imm = 0x1050
callq 0xb6f0
movq %rax, %r15
leaq 0xbb0(%rax), %rdi
callq 0xf262
movq (%r12), %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rdi
leaq 0x5b82d(%rip), %rsi     # 0x69422
movq %r15, %rdx
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rsi
movl $0xa, %edi
callq 0xb690
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/units/redirect/redirect_test.c
// Function: redirect_test_close
scdcint_t redirect_test_close(void *dataprov)
{
  TRACE_F("dataprov: %p", dataprov);

  redirect_call_t *rc = dataprov;

#if REDIRECT_CALL_PARAMS_CACHE
  redirect_cache_t *rch = (redirect_cache_t *) (rc + 1);

  redirect_cache_release(rch);
#endif

  free(rc);

  TRACE_F("return");

  return SCDC_SUCCESS;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x7e372(%rip), %r12     # 0x8bfa0
movq (%r12), %rdi
leaq 0x5b7b7(%rip), %rbx     # 0x693f0
leaq 0x5b7ed(%rip), %r14     # 0x6942d
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rdi
leaq 0x5b7e9(%rip), %rsi     # 0x69441
movq %r15, %rdx
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rsi
movl $0xa, %edi
callq 0xb690
leaq 0xbb0(%r15), %rdi
callq 0xf2c2
movq %r15, %rdi
callq 0xb650
movq (%r12), %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rcx
leaq 0x5b7ae(%rip), %rdi     # 0x6944e
movl $0x6, %esi
movl $0x1, %edx
callq 0xba90
movq (%r12), %rsi
movl $0xa, %edi
callq 0xb690
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_cache.cc
// Function: redirect_cache_create
void redirect_cache_create(redirect_cache_t *rch)
{
  TRACE_F(" ");

  rch->client = 1;

  redirect_cache_reset_params(rch);

  rch->nentries = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7d336(%rip), %r14     # 0x8bfa0
movq (%r14), %rdi
leaq 0x5a91b(%rip), %rsi     # 0x6958f
leaq 0x5a929(%rip), %rdx     # 0x695a4
xorl %eax, %eax
callq 0xb7a0
movq (%r14), %rsi
movl $0x20, %edi
callq 0xb690
movq (%r14), %rsi
movl $0xa, %edi
callq 0xb690
movl $0x1, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x298(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_cache.cc
// Function: redirect_cache_register_param_dense
void redirect_cache_register_param_dense(redirect_cache_t *rch, const char *id, int type, redirect_param_dense_t *param)
{
  TRACE_F("id: %s, type: %d, size: %" rdint_fmt, id, type, param->size);

  if (rch->nparams < REDIRECT_CACHE_PARAMS_MAX)
  {
    rch->params[rch->nparams].type = type;
    rch->params[rch->nparams].size = param->size;
    rch->params[rch->nparams].buf = param->buf;
    rch->params[rch->nparams].hash = 0;

    ++rch->nparams;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x7d1f5(%rip), %r12     # 0x8bfa0
movq (%r12), %rdi
leaq 0x5a7d9(%rip), %rsi     # 0x6958f
leaq 0x5a814(%rip), %rdx     # 0x695d1
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rdi
movq 0x8(%r14), %r8
leaq 0x5a822(%rip), %rsi     # 0x695f5
movq %r15, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rsi
movl $0xa, %edi
callq 0xb690
movq 0x8(%rbx), %rax
cmpq $0xf, %rax
jg 0xee1f
leaq (%rax,%rax,4), %rcx
movl %ebp, 0x18(%rbx,%rcx,8)
movq 0x8(%r14), %rdx
movq %rdx, 0x20(%rbx,%rcx,8)
movq (%r14), %rdx
movq %rdx, 0x28(%rbx,%rcx,8)
movl $0x0, 0x30(%rbx,%rcx,8)
incq %rax
movq %rax, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq