LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/tanakh[P]icfpc2015/main.cpp
// Function: print_board(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&)
void print_board(const vector<vector<int>> &bd)
{
  int w = bd[0].size()/2, h = bd.size();
  for (int y = 0; y < h; y++) {
    for (int xx = 0; xx < w; xx++) {
      int x = xx * 2 + y % 2;
      if (y % 2 == 1) vlog() << " ";
      vlog() << (bd[y][x]==1 ? "o" : bd[y][x]==2 ? "#" : bd[y][x]==3 ? "@" : ".");
      if (y % 2 == 0) vlog() << " ";
    }
    vlog() << endl;
  }
  vlog() << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
movq 0x8(%rcx), %rsi
subq (%rcx), %rsi
shrq $0x3, %rsi
subq %rcx, %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
xorl %r12d, %r12d
testl %esi, %esi
cmovlel %r12d, %esi
movq %rsi, 0x8(%rsp)
testl %eax, %eax
cmovlel %r12d, %eax
movq %rax, 0x10(%rsp)
leaq 0x18bde(%rip), %rbp     # 0x1d698
movq 0x17527(%rip), %r14     # 0x1bfe8
cmpq 0x10(%rsp), %r12
je 0x4b9d
movl %r12d, %r13d
andl $0x1, %r13d
shll $0x2, %r13d
movq 0x8(%rsp), %r15
subq $0x1, %r15
jb 0x4b81
testb $0x1, %r12b
je 0x4b07
cmpb $0x0, 0x18b9d(%rip)     # 0x1d690
movq %rbp, %rdi
je 0x4afb
movq %r14, %rdi
leaq 0xda40(%rip), %rsi      # 0x12542
callq 0x32f0
cmpb $0x0, 0x18b82(%rip)     # 0x1d690
movq %rbp, %rdi
je 0x4b16
movq %r14, %rdi
movq (%rbx), %rax
imulq $0x18, %r12, %rcx
movq (%rax,%rcx), %rax
movl (%rax,%r13), %eax
leaq 0xd953(%rip), %rsi      # 0x1247f
cmpl $0x1, %eax
je 0x4b52
cmpl $0x2, %eax
jne 0x4b3f
leaq 0xd944(%rip), %rsi      # 0x12481
jmp 0x4b52
leaq 0xd93d(%rip), %rsi      # 0x12483
cmpl $0x3, %eax
je 0x4b52
leaq 0xdb1d(%rip), %rsi      # 0x1266f
callq 0x32f0
testb $0x1, %r12b
jne 0x4b78
cmpb $0x0, 0x18b2c(%rip)     # 0x1d690
movq %rbp, %rdi
je 0x4b6c
movq %r14, %rdi
leaq 0xd9cf(%rip), %rsi      # 0x12542
callq 0x32f0
addq $0x8, %r13
jmp 0x4adc
cmpb $0x0, 0x18b08(%rip)     # 0x1d690
movq %rbp, %rdi
je 0x4b90
movq %r14, %rdi
callq 0x3130
incq %r12
jmp 0x4ac1
cmpb $0x0, 0x18aec(%rip)     # 0x1d690
je 0x4baf
movq 0x1743b(%rip), %rdi     # 0x1bfe8
jmp 0x4bb6
leaq 0x18ae2(%rip), %rdi     # 0x1d698
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3130
// File: /workspace/github_cpp_makefile_star2_O2/tanakh[P]icfpc2015/main.cpp
// Function: print_board_(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&, std::complex<int> const&, unit const&, int)
void print_board_(const vector<vector<int>> &bd_, const pt &pos, const unit &u, int rot)
{
  vector<vector<int>> bd = bd_;

  for (auto &c: u.members) {
    pt p = pos + rot_pivot(c, u.pivot, rot);
    assert(p.imag()>=0&&p.imag()<bd.size()&&p.real()>=0&&p.real()<bd[0].size());
    bd[p.imag()][p.real()] = 2;
  }
  pt q = pos + u.pivot;
  if (q.real() >= 0 && q.real() < (int)bd[0].size() &&
      q.imag() >= 0 && q.imag() < (int)bd.size())
    bd[q.imag()][q.real()] = 3;
  print_board(bd);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x8(%rsp), %rdi
callq 0x98fe
movq (%r12), %r15
movq 0x8(%r12), %rbx
movq %r12, 0x20(%rsp)
addq $0x18, %r12
pushq $0x18
popq %r13
cmpq %rbx, %r15
je 0x4c93
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x9666
movq %rax, %rcx
movq %rax, %rdx
shrq $0x20, %rdx
movq (%r14), %rsi
movq %rsi, %rax
shrq $0x20, %rax
addl %edx, %eax
js 0x4d06
movl %eax, %edi
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %rax
subq %r8, %rax
cqto
idivq %r13
cmpq %rdi, %rax
jbe 0x4d06
addq %rcx, %rsi
movl %esi, %eax
andl $0x80000000, %eax       # imm = 0x80000000
jne 0x4d06
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq 0x8(%r8), %rax
subq (%r8), %rax
sarq $0x2, %rax
cmpq %rsi, %rax
jbe 0x4d06
imulq $0x18, %rdi, %rax
movq (%r8,%rax), %rax
movl $0x2, (%rax,%rsi,4)
addq $0x8, %r15
jmp 0x4c02
movq (%r14), %rsi
movq 0x20(%rsp), %rax
movl 0x18(%rax), %ecx
addl %esi, %ecx
js 0x4ce3
shrq $0x20, %rsi
addl 0x1c(%rax), %esi
js 0x4ce3
movq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rax
subq (%rdi), %rax
shrq $0x2, %rax
cmpl %eax, %ecx
jge 0x4ce3
movq 0x10(%rsp), %rax
subq %rdi, %rax
cqto
idivq %r13
cmpl %eax, %esi
jge 0x4ce3
movl %esi, %eax
imulq $0x18, %rax, %rax
movl %ecx, %ecx
movq (%rdi,%rax), %rax
movl $0x3, (%rax,%rcx,4)
leaq 0x8(%rsp), %rdi
callq 0x4a6c
leaq 0x8(%rsp), %rdi
callq 0x9958
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd6d2(%rip), %rdi      # 0x123df
leaq 0xd70f(%rip), %rsi      # 0x12423
leaq 0xd76a(%rip), %rcx      # 0x12485
movl $0x1cc, %edx            # imm = 0x1CC
callq 0x31c0
jmp 0x4d27
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9958
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O2/tanakh[P]icfpc2015/main.cpp
// Function: to_ans[abi:cxx11](std::vector<int, std::allocator<int>> const&)
string to_ans(const vector<int> &v)
{
  string ret;

  // for (int i = 0; i < (int)v.size(); i++) {
  //   ret += to_char((command)v[i]);
  // }

  // return ret;

  for (int i = 0; i < (int)v.size(); ) {
    bool done = false;
    for (auto &w: ppw) {
      bool ok = true;
      for (int j = 0; j < (int)w.size(); j++) {
        if (!(i+j<(int)v.size() && v[i+j] == to_command(w[j]))) {
          ok = false;
          break;
        }
      }
      if (ok) {
        ret += w;
        i += w.size();
        done = true;
        break;
      }
    }
    if (!done) {
      ret += to_char((command)v[i]);
      i++;
    }
  }

  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdi, (%rsp)
movb $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x2, %rax
cmpl %eax, %ecx
jge 0x53e7
movq 0x18344(%rip), %r15     # 0x1d678
movq %rcx, 0x8(%rsp)
movslq %ecx, %rbx
leaq (,%rbx,4), %rax
movq %rax, 0x10(%rsp)
leaq 0x18318(%rip), %rax     # 0x1d668
cmpq %rax, %r15
je 0x53c6
leaq 0x20(%r15), %r12
xorl %r13d, %r13d
movslq 0x28(%r15), %rax
cmpq %rax, %r13
jge 0x53aa
leaq (%rbx,%r13), %rcx
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
shrq $0x2, %rdx
movslq %edx, %rdx
cmpq %rdx, %rcx
jge 0x539d
addq 0x10(%rsp), %rax
movl (%rax,%r13,4), %ebp
movq (%r12), %rax
movsbl (%rax,%r13), %edi
callq 0x44ae
incq %r13
cmpl %eax, %ebp
je 0x535c
movq %r15, %rdi
callq 0x3340
movq %rax, %r15
jmp 0x5349
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x3530
movl 0x28(%r15), %eax
movq 0x8(%rsp), %rcx
addl %eax, %ecx
jmp 0x531a
movq (%r14), %rax
movl (%rax,%rbx,4), %edi
callq 0x43bb
movsbl %al, %esi
movq (%rsp), %rdi
callq 0x32a0
pushq $0x1
popq %rax
movq 0x8(%rsp), %rcx
jmp 0x53bf
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x53fe
jmp 0x53fe
movq %rax, %r14
movq (%rsp), %rdi
callq 0x3550
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O2/tanakh[P]icfpc2015/main.cpp
// Function: make_board(problem const&)
vector<vector<int>> make_board(const problem &prob)
{
  vector<vector<int>> bd(prob.height, vector<int>(prob.width*2, 1));

  for (int y = 0; y < prob.height; y++)
    for (int x = 0; x < prob.width; x++)
      bd[y][x*2+y%2] = 0;

  for (auto &p: prob.filled)
    bd[p.imag()][p.real()] = 1;

  return bd;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x24(%rsi), %r15
movslq 0x20(%rsi), %rsi
addq %rsi, %rsi
leaq 0xc(%rsp), %rdx
movl $0x1, (%rdx)
leaq 0x10(%rsp), %r12
leaq 0xb(%rsp), %rcx
movq %r12, %rdi
callq 0x9bd4
leaq 0xa(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x9c2a
leaq 0x10(%rsp), %rdi
callq 0xd7a4
xorl %eax, %eax
movslq 0x24(%r14), %rcx
cmpq %rcx, %rax
jge 0x5b0f
movl %eax, %ecx
andl $0x1, %ecx
shll $0x2, %ecx
imulq $0x18, %rax, %rdx
addq (%rbx), %rdx
xorl %esi, %esi
movslq 0x20(%r14), %rdi
cmpq %rdi, %rsi
jge 0x5b0a
movq (%rdx), %rdi
addq %rcx, %rdi
andl $0x0, (%rdi,%rsi,8)
incq %rsi
jmp 0x5af2
incq %rax
jmp 0x5ad8
movq 0x28(%r14), %rax
movq 0x30(%r14), %rcx
movq (%rbx), %rdx
cmpq %rcx, %rax
je 0x5b3b
movslq 0x4(%rax), %rsi
imulq $0x18, %rsi, %rsi
movslq (%rax), %rdi
movq (%rdx,%rsi), %rsi
movl $0x1, (%rsi,%rdi,4)
addq $0x8, %rax
jmp 0x5b1a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xd7a4
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O2/tanakh[P]icfpc2015/main.cpp
// Function: get_words[abi:cxx11]()
vector<string> get_words()
{
  vector<string> words;
  {
    vector<pair<int, string>> ws;
    for (auto &w: ppw)
      ws.emplace_back(-w.length(), w);
    sort(ws.begin(), ws.end());
    for (auto &it: ws)
      words.push_back(it.second);
  }
  return words;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsp, %r14
andq $0x0, 0x10(%r14)
movaps %xmm0, (%r14)
movq 0x17aeb(%rip), %r15     # 0x1d678
leaq 0x17ad4(%rip), %r13     # 0x1d668
leaq 0x18(%rsp), %r12
cmpq %r13, %r15
je 0x5bc5
leaq 0x20(%r15), %rdx
xorl %eax, %eax
subq 0x28(%r15), %rax
movq %rax, 0x18(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x9c80
movq %r15, %rdi
callq 0x3340
movq %rax, %r15
jmp 0x5b99
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xeb21
movq (%rsp), %r14
movq 0x8(%rsp), %r15
cmpq %r15, %r14
je 0x5bf6
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9cb2
addq $0x20, %r14
jmp 0x5bdc
movq %rsp, %rdi
callq 0x9cde
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5c13
jmp 0x5c13
movq %rax, %r14
movq %rsp, %rdi
callq 0x9cde
movq %rbx, %rdi
callq 0x9d00
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O2/tanakh[P]icfpc2015/main.cpp
// Function: power_score(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int power_score(const string &cmds)
{
  int ret = 0;

  auto words = get_words();

  for (auto &word: words) {
    int reps = 0;
    for (int i = 0; i < (int)cmds.size(); i++) {
      bool ok = true;
      for (int j = 0; j < (int)word.size(); j++) {
        if (!(i + j < (int)cmds.size() && tolower(cmds[i+j]) == tolower(word[j]))) {
          ok = false;
          break;
        }
      }
      if (ok) reps++;
    }

    if (reps > 0) ret += 300;
    ret += 2 * word.length() * reps;
  }

  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x5b5f
movq (%r14), %r15
movq 0x8(%r14), %rax
movq %rax, 0x10(%rsp)
movl 0x8(%rbx), %eax
movq (%rbx), %rcx
movq %rcx, 0x8(%rsp)
xorl %ebx, %ebx
testl %eax, %eax
movl $0x0, %ecx
movl %eax, 0x4(%rsp)
cmovgl %eax, %ecx
movq %rcx, 0x20(%rsp)
cmpq 0x10(%rsp), %r15
je 0x5d35
movq %rbx, 0x18(%rsp)
xorl %ecx, %ecx
movq 0x8(%rsp), %rbx
movl 0x4(%rsp), %eax
movl %eax, %r13d
xorl %edx, %edx
cmpq 0x20(%rsp), %rcx
je 0x5d14
movq %rcx, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movl %r13d, %r13d
movq 0x8(%r15), %rax
cltq
testl %eax, %eax
movl $0x0, %r12d
movq %rax, 0x28(%rsp)
cmovgl %eax, %r12d
xorl %ecx, %ecx
movq %rcx, %r14
cmpq %rcx, %r12
je 0x5cf3
cmpq %r14, %r13
je 0x5cf3
movsbl (%rbx,%r14), %edi
callq 0x33c0
movl %eax, %ebp
movq (%r15), %rax
movsbl (%rax,%r14), %edi
callq 0x33c0
leaq 0x1(%r14), %rcx
cmpl %eax, %ebp
je 0x5cc5
xorl %eax, %eax
cmpq 0x28(%rsp), %r14
setge %al
movq 0x38(%rsp), %rdx
addl %eax, %edx
movq 0x30(%rsp), %rcx
incq %rcx
decl %r13d
incq %rbx
jmp 0x5c98
movq 0x18(%rsp), %rcx
leal 0x12c(%rcx), %eax
testl %edx, %edx
cmovel %ecx, %eax
imull 0x8(%r15), %edx
leal (%rax,%rdx,2), %ebx
addq $0x20, %r15
jmp 0x5c78
leaq 0x40(%rsp), %rdi
callq 0x9d00
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tanakh[P]icfpc2015/main.cpp
// Function: uposs(unit const&, std::complex<int> const&, int)
pair<pair<int,int>, set<pair<int,int>>> uposs(const unit &u, const pt &pos, int rot)
{
  set<pair<int,int>> ss;
  for (auto &c: u.members) {
    auto d = rot_pivot(c + pos, u.pivot + pos, rot);
    ss.insert(make_pair(d.real(), d.imag()));
  }
  return make_pair(pt2pair(u.pivot + pos), ss);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
leaq 0x20(%rsp), %rax
andl $0x0, (%rax)
movq %rdx, %r14
andq $0x0, 0x8(%rax)
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq (%rsi), %r13
movq 0x8(%rsi), %rbx
movq %rsp, %r12
cmpq %rbx, %r13
je 0x613f
movq (%r13), %rax
movl (%r14), %ecx
leal (%rcx,%rax), %edx
shrq $0x20, %rax
movl 0x4(%r14), %esi
addl %esi, %eax
shlq $0x20, %rax
orq %rax, %rdx
movq %rdx, (%rsp)
movq 0x18(%r15), %rax
addl %eax, %ecx
shrq $0x20, %rax
addl %esi, %eax
shlq $0x20, %rax
orq %rax, %rcx
movq %rcx, 0x10(%rsp)
movq %r12, %rdi
leaq 0x10(%rsp), %rsi
movl %ebp, %edx
callq 0x9666
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0xd33e
addq $0x8, %r13
jmp 0x60dd
movq 0x18(%r15), %rax
movl (%r14), %ecx
addl %eax, %ecx
shrq $0x20, %rax
addl 0x4(%r14), %eax
shlq $0x20, %rax
orq %rax, %rcx
movq 0x8(%rsp), %rbx
movq %rcx, (%rbx)
movq %rbx, %rdi
addq $0x8, %rdi
leaq 0x18(%rsp), %rsi
callq 0xc562
leaq 0x18(%rsp), %rdi
callq 0xa452
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6190
jmp 0x6190
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xa452
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O2/tanakh[P]icfpc2015/main.cpp
// Function: select(std::vector<std::pair<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::vector<double, std::allocator<double>>>, std::allocator<std::pair<std::pair<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::vector<double, std::allocator<double>>>>>&)
vector<double> select(vector<pair<pair<int, string>, vector<double>>> &ord)
{
  double total_adapt = 0;
  for (auto &c: ord)
    total_adapt += pow(log((double)c.first.first), 2);

  for (auto &c: ord) {
    double adp = pow(log((double)c.first.first), 2);
    if (genrand_real1() < (adp/total_adapt))
      return c.second;
    total_adapt -= adp;
  }

  return ord[genrand_int31() % ord.size()].second;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %r12
xorpd %xmm1, %xmm1
movsd %xmm1, 0x8(%rsp)
cmpq %r12, %r15
je 0x742d
cvtsi2sdl (%r15), %xmm0
callq 0x3280
mulsd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
addq $0x40, %r15
jmp 0x7404
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x747c
cvtsi2sdl (%r15), %xmm0
callq 0x3280
mulsd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
callq 0x3a22
movsd 0x10(%rsp), %xmm3
movapd %xmm3, %xmm1
movsd 0x8(%rsp), %xmm2
divsd %xmm2, %xmm1
ucomisd %xmm0, %xmm1
ja 0x74a2
subsd %xmm3, %xmm2
movsd %xmm2, 0x8(%rsp)
addq $0x40, %r15
jmp 0x7434
callq 0x3a17
movq (%r14), %rcx
movq 0x8(%r14), %rsi
subq %rcx, %rsi
sarq $0x6, %rsi
xorl %edx, %edx
divq %rsi
shlq $0x6, %rdx
leaq (%rcx,%rdx), %r15
addq $0x28, %r15
jmp 0x74a6
addq $0x28, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa04c
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tanakh[P]icfpc2015/./picojson.h
// Function: picojson::value::operator=(picojson::value const&)
inline value& value::operator=(const value& x) {
    if (this != &x) {
      value t(x);
      swap(t);
    }
    return *this;
  }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x9d63
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xa79c
movl (%rbx), %eax
movl (%r14), %ecx
movl %ecx, (%rbx)
movl %eax, (%r14)
movsd 0x8(%rbx), %xmm0
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movsd %xmm0, 0x8(%r14)
movq %r14, %rdi
callq 0x9760
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tanakh[P]icfpc2015/./picojson.h
// Function: picojson::input<std::istreambuf_iterator<char, std::char_traits<char>>>::getc()
int getc() {
      if (ungot_) {
	ungot_ = false;
	return last_ch_;
      }
      if (cur_ == end_) {
	last_ch_ = -1;
	return -1;
      }
      if (last_ch_ == '\n') {
	line_++;
      }
      last_ch_ = *cur_ & 0xff;
      ++cur_;
      return last_ch_;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x24(%rdi)
jne 0xad2e
movb $0x0, 0x24(%rbx)
jmp 0xad66
leaq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0xba2c
testb %al, %al
je 0xad47
orl $-0x1, 0x20(%rbx)
pushq $-0x1
popq %rax
jmp 0xad69
cmpl $0xa, 0x20(%rbx)
jne 0xad50
incl 0x28(%rbx)
movq %rbx, %rdi
callq 0xba5c
movzbl %al, %eax
movl %eax, 0x20(%rbx)
movq %rbx, %rdi
callq 0xba16
movl 0x20(%rbx), %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/other_fct.cpp
// Function: Subtract(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&, int)
vector<int> Subtract(const vector<int>& f, const vector<int>& g,int p)//computes f-g over F_p
{
  int max_size = max(f.size(),g.size());
  int min_size = max(f.size(),g.size());
  vector<int> result(max_size,0);
  for (int i = 0; i < min_size; ++i)
    {
      result[i] = (p+f[i] - g[i]) % p;
    }
  if (f.size() > g.size())
    {
      for (int i = g.size(); i < max_size; ++i)
	{
	  result[i] = f[i];
	} 
    }
  else
    {
       for (int i = g.size(); i < max_size; ++i)
	{
	  result[i] = (p-g[i]) % p;
	} 
    }
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x2, %rax
movq 0x8(%rdx), %r13
subq (%rdx), %r13
sarq $0x2, %r13
cmpq %r13, %rax
cmovaq %rax, %r13
movslq %r13d, %r12
leaq 0x4(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x3(%rsp), %rcx
movq %r12, %rsi
callq 0x39c4
movq (%r15), %rsi
movq (%r14), %rcx
movq (%rbx), %rdi
xorl %r8d, %r8d
testl %r12d, %r12d
cmovlel %r8d, %r12d
cmpq %r8, %r12
je 0x3099
movl (%rsi,%r8,4), %eax
addl %ebp, %eax
subl (%rcx,%r8,4), %eax
cltd
idivl %ebp
movl %edx, (%rdi,%r8,4)
incq %r8
jmp 0x307e
movq 0x8(%r15), %rax
subq %rsi, %rax
movq 0x8(%r14), %rdx
subq %rcx, %rdx
movq %rdx, %r8
shrq $0x2, %r8
movq (%rbx), %rdi
movslq %r8d, %r8
movslq %r13d, %r9
cmpq %rdx, %rax
jbe 0x30ce
cmpq %r9, %r8
jge 0x30e5
movl (%rsi,%r8,4), %eax
movl %eax, (%rdi,%r8,4)
incq %r8
jmp 0x30bc
cmpq %r9, %r8
jge 0x30e5
movl %ebp, %eax
subl (%rcx,%r8,4), %eax
cltd
idivl %ebp
movl %edx, (%rdi,%r8,4)
incq %r8
jmp 0x30ce
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/other_fct.cpp
// Function: Add(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&, int)
vector<int> Add(const vector<int>& f, const vector<int>& g,int p)//computes f-g over F_p
{
  int max_size = max(f.size(),g.size());
  int min_size = max(f.size(),g.size());
  vector<int> result(max_size,0);
  for (int i = 0; i < min_size; ++i)
    {
      result[i] = (f[i] + g[i]) % p;
    }
  if (f.size() > g.size())
    {
      for (int i = g.size(); i < max_size; ++i)
	{
	  result[i] = f[i];
	} 
    }
  else
    {
       for (int i = g.size(); i < max_size; ++i)
	{
	  result[i] = g[i];
	} 
    }
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x2, %rax
movq 0x8(%rdx), %r13
subq (%rdx), %r13
sarq $0x2, %r13
cmpq %r13, %rax
cmovaq %rax, %r13
movslq %r13d, %r12
leaq 0x4(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x3(%rsp), %rcx
movq %r12, %rsi
callq 0x39c4
movq (%r15), %rcx
movq (%r14), %rsi
movq (%rbx), %rdi
xorl %r8d, %r8d
testl %r12d, %r12d
cmovlel %r8d, %r12d
cmpq %r8, %r12
je 0x316e
movl (%rsi,%r8,4), %eax
addl (%rcx,%r8,4), %eax
cltd
idivl %ebp
movl %edx, (%rdi,%r8,4)
incq %r8
jmp 0x3155
movq 0x8(%r15), %r8
subq %rcx, %r8
movq 0x8(%r14), %r9
subq %rsi, %r9
movq %r9, %rdx
shrq $0x2, %rdx
movq (%rbx), %rax
movslq %edx, %rdx
movslq %r13d, %rdi
cmpq %r9, %r8
jbe 0x31a1
cmpq %rdi, %rdx
jge 0x31b1
movl (%rcx,%rdx,4), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
jmp 0x3191
cmpq %rdi, %rdx
jge 0x31b1
movl (%rsi,%rdx,4), %ecx
movl %ecx, (%rax,%rdx,4)
incq %rdx
jmp 0x31a1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/other_fct.cpp
// Function: LT(std::vector<int, std::allocator<int>> const&)
int LT(const vector<int>& poly)
{
  for (int i = poly.size()-1; i >= 0; --i)
    {
      if (poly[i] >0)
	return i;
    }
  cout << "Zero polynomial!" << endl;
  return 0;
}

// Assembly:
pushq %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
subq %rcx, %rax
shrq $0x2, %rax
movl %eax, %edx
decq %rdx
decl %eax
js 0x3217
movl %edx, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
decq %rdx
cmpl $0x0, (%rcx,%rsi,4)
jle 0x3200
jmp 0x3234
movq 0x14dba(%rip), %rdi     # 0x17fd8
leaq 0xbe8b(%rip), %rsi      # 0xf0b0
callq 0x2180
movq %rax, %rdi
callq 0x20d0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/other_fct.cpp
// Function: Tail(std::vector<int, std::allocator<int>> const&)
vector<int> Tail(const vector<int>& poly)
{
  vector<int> tail = poly;
  //improve this by LT extra!
  int LT_ = LT(poly);
  tail[LT_] = 0;
  return tail;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3a1a
movq %r14, %rdi
callq 0x31ec
cltq
movq (%rbx), %rcx
andl $0x0, (%rcx,%rax,4)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2dfe
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/other_fct.cpp
// Function: Inverse(int, int)
int Inverse(int c, int p)//compute c^-1 in F_p, can do a table for large fields
{
  int c_copy = c;
  if (c == 0)
    {
      cout << "Next polynomial added to input set!" << endl;
      //cout << "Error! No inverse to 0 exists!" << endl;
      return 0;
    }
  for (int i = 1; i < p; ++i)
    {
      if (c == 1)
	{
	  return i;
	}
      else
	{
	  c = (c + c_copy)%p;
	}
    }
  cout << "Error, no inverse found! Sure that p is prime?" << endl;
  return 0;
}

// Assembly:
testl %edi, %edi
je 0x329d
movl %esi, %r8d
pushq $0x1
popq %rcx
leaq 0xbe60(%rip), %rsi      # 0xf0e5
movl %edi, %eax
cmpl %r8d, %ecx
jge 0x32a4
cmpl $0x1, %eax
je 0x32bf
addl %edi, %eax
cltd
idivl %r8d
incl %ecx
movl %edx, %eax
jmp 0x3287
leaq 0xbe1d(%rip), %rsi      # 0xf0c1
pushq %rax
movq 0x14d2c(%rip), %rdi     # 0x17fd8
callq 0x2180
movq %rax, %rdi
callq 0x20d0
xorl %ecx, %ecx
addq $0x8, %rsp
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/other_fct.cpp
// Function: binom(int, int)
int binom(int n, int k)   //from geeksforgeeks.org
{
  if (n < k)
    return 0;
  if (k < 0 || n < 0)
    return 0;
    int res = 1;  
  
    // Since C(n, k) = C(n, n-k)  
    if ( k > n - k )  
        k = n - k;  
  
    // Calculate value of  
    // [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]  
    for (int i = 0; i < k; ++i)  
    {  
        res *= (n - i);  
        res /= (i + 1);  
    }  
  
    return res;  
}

// Assembly:
movl %edi, %ecx
subl %esi, %ecx
setl %dl
movl %esi, %eax
orl %edi, %eax
sets %r8b
xorl %eax, %eax
orb %dl, %r8b
jne 0x32ff
cmpl %esi, %ecx
cmovll %ecx, %esi
xorl %ecx, %ecx
testl %esi, %esi
cmovgl %esi, %ecx
negl %ecx
pushq $0x1
popq %rsi
movl %esi, %eax
leal (%rcx,%rsi), %edx
cmpl $0x1, %edx
je 0x32ff
imull %edi, %eax
cltd
idivl %esi
incl %esi
decl %edi
jmp 0x32eb
retq
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/other_fct.cpp
// Function: Create_binom_table(int, int)
vector<vector<term_int>> Create_binom_table(int n, int d)
{
  vector<vector<term_int>> Binom_table = {};
  for (int i = 0; i <= n; ++i)
    {
      vector<term_int> table_n = {};
      for (int j = 0; j <= d; ++j)
	{
	  table_n.push_back(binom(i,j));
	}
      Binom_table.push_back(table_n);
    }
  return Binom_table;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movl %esi, %r14d
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movq %rdi, (%rsp)
movups %xmm0, (%rdi)
xorl %r15d, %r15d
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %r13
cmpl %r14d, %r15d
jg 0x3381
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
xorl %ebx, %ebx
cmpl %ebp, %ebx
jg 0x3368
movl %r15d, %edi
movl %ebx, %esi
callq 0x32c2
cltq
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x3d62
incl %ebx
jmp 0x3344
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x3a68
movq %r12, %rdi
callq 0x2d00
incl %r15d
jmp 0x332f
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3396
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2d00
movq (%rsp), %rdi
callq 0x2be6
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/other_fct.cpp
// Function: term_to_int(std::vector<int, std::allocator<int>>, int)
term_int term_to_int(term_vec term, int n) //computes entry in macaulay matrix
{
  //cout << "into term_to_int" << endl;
  //get degree first
  int d = 0;
  for (int i = 0; i < term.size(); ++i)
    {
      d += term[i];
    }
  //cout << "degree: " << d << endl;
  //int mac = binom(n+d-1,n);//get all polynomials with degrees up to d-1
  int mac = 0;
  if (n+d > 0)
    {
      mac += (binom_table[n+d-1])[n];//binom(n+d-1,n);//get all polynomials with degrees up to d-1
    }
  //cout << "after lower degrees: " << mac << endl;
  mac ++; //go to x_n^d

  for (int i = n-1; i >= 0; i--)
    {
      d -= term[i]; //get degree in x_1,...,x_i
      if (i+d > 0 && d > 0)
	{
	  mac += (binom_table[i+d-1])[d-1];//binom(i+d-1,d-1); //compute # of polynomials of degree d-1 in (x_1,...,x_i,x_i+1)
	  //mac += binom(i+d-1,d-1);
	}
    }
  //left here!
  return mac;
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
xorl %edi, %edi
xorl %ecx, %ecx
cmpq %rdi, %rdx
je 0x33d3
addl (%rax,%rdi,4), %ecx
incq %rdi
jmp 0x33c6
movl %ecx, %edi
movq 0x14dac(%rip), %rdx     # 0x18188
addl %esi, %edi
jle 0x33f6
movl %edi, %edi
imulq $0x18, %rdi, %rdi
movslq %esi, %r8
movq -0x18(%rdx,%rdi), %rdi
movl (%rdi,%r8,8), %edi
incl %edi
jmp 0x33f9
pushq $0x1
popq %rdi
addq $-0x18, %rdx
movl %esi, %esi
testl %esi, %esi
jle 0x3425
decq %rsi
movl %esi, %r8d
subl (%rax,%r8,4), %ecx
jle 0x33ff
leal (%rcx,%rsi), %r8d
imulq $0x18, %r8, %r8
movq (%rdx,%r8), %r8
movl %ecx, %r9d
addl -0x8(%r8,%r9,8), %edi
jmp 0x33ff
movslq %edi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/other_fct.cpp
// Function: create_degrees(int, int)
vector<int> create_degrees(int d, int n)
{
  vector<int> degrees = {};
  for (int i = 0; i < d; ++i)
    {
      degrees.push_back(lower_degrees(i,n));
    }
return degrees;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
xorl %r15d, %r15d
testl %esi, %esi
cmovlel %r15d, %r14d
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0xc(%rsp), %r12
cmpl %r15d, %r14d
je 0x3479
movl %r15d, %edi
movl %ebp, %esi
callq 0x349c
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x40aa
incl %r15d
jmp 0x3456
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2dfe
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/other_fct.cpp
// Function: lower_degrees(int, int)
int lower_degrees(int d, int n) //gets the number of x_1^(d-1) (largest term of degree d-1), is highly inefficient!
{
  //cout << "into lower degrees!" << endl;
  int number = 0;
  for (int i = 0; i < d; ++i)
    {
      number += binom(n+i-1,i);
    }
  return number;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
decl %ebx
xorl %r14d, %r14d
testl %edi, %edi
cmovlel %r14d, %ebp
xorl %r15d, %r15d
cmpl %r15d, %ebp
je 0x34ce
leal (%rbx,%r15), %edi
movl %r15d, %esi
callq 0x32c2
addl %eax, %r14d
incl %r15d
jmp 0x34b5
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/other_fct.cpp
// Function: is_Smaller(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&)
bool is_Smaller(const vector<int>& t, const vector<int>& u) //checks if t == u for t,u terms, order is degrevlex
{
  //cout << "is smaller called! " << endl;
  /*for (int i = 0; i < u.size(); ++i)
    {
      cout << u[i] << " ";
    }
  cout << endl;
  cout << "t:";
  for (int i = 0; i < t.size(); ++i)
    {
      cout << t[i] << " ";
    }
  cout << endl;
  */

  if (t.size() != u.size())
    {
      cout << "Error! wrong sizes in is_smaller" << endl;
      cout << "t.size: " << t.size() << endl;
      cout << "u.size: " << u.size() << endl;
    }
  int deg_t = 0;
  int deg_u = 0;
  for (int i = 0; i < u.size(); ++i)
    {
      deg_t += t[i];
      deg_u += u[i];
    }
   
  if (deg_t < deg_u)
    return true;
  if (deg_t > deg_u)
    return false;

  //case deg(t) = deg(u)
  int n = t.size();
  for (int i = n-1; i >= 0; --i)
    {
      if (t[i] > u[i])
	return true;
      if (t[i] < u[i])
	return false;
    }
  //case equal
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rsi
subq %rcx, %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rax
subq %rdx, %rax
cmpq %rax, %rsi
je 0x357f
movq 0x14ad1(%rip), %r15     # 0x17fd8
leaq 0xbc06(%rip), %rsi      # 0xf114
movq %r15, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20d0
leaq 0xbc10(%rip), %rsi      # 0xf135
movq %r15, %rdi
callq 0x2180
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x2, %rsi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20d0
leaq 0xbbef(%rip), %rsi      # 0xf13e
movq %r15, %rdi
callq 0x2180
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x2, %rsi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20d0
movq (%r14), %rdx
movq 0x8(%r14), %rax
movq (%rbx), %rcx
subq %rdx, %rax
sarq $0x2, %rax
xorl %esi, %esi
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %rsi, %rax
je 0x359b
addl (%rcx,%rsi,4), %edi
addl (%rdx,%rsi,4), %r8d
incq %rsi
jmp 0x358a
movb $0x1, %al
cmpl %r8d, %edi
jl 0x35e0
jle 0x35a8
xorl %eax, %eax
jmp 0x35e0
movq 0x8(%rbx), %rax
subq %rcx, %rax
shrq $0x2, %rax
movl %eax, %esi
movl %esi, %eax
testl %esi, %esi
jle 0x35d8
movl -0x4(%rcx,%rsi,4), %edi
movl -0x4(%rdx,%rsi,4), %r8d
cmpl %r8d, %edi
jg 0x35d5
decq %rsi
cmpl %r8d, %edi
jge 0x35b5
xorl %edi, %edi
jmp 0x35d8
movb $0x1, %dil
testl %eax, %eax
setle %al
orb %dil, %al
andb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/other_fct.cpp
// Function: is_Equal(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&)
bool is_Equal(const vector<int>& t, const vector<int>& u) //checks if t < u for t,u terms, order is deglex
{
  if (t.size() != u.size())
    {
      cout << "Error! wrong sizes in is_equal!" << endl;
    }

  int n = t.size();
  for (int i = 0; i < t.size(); ++i)
    {
      if (t[i] != u[i])
	return false;
    }
  return true;//they are equal
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
subq %rdx, %rsi
cmpq %rsi, %rcx
je 0x3633
movq %rdi, %r14
movq 0x149c6(%rip), %rdi     # 0x17fd8
leaq 0xbb2e(%rip), %rsi      # 0xf147
callq 0x2180
movq %rax, %rdi
callq 0x20d0
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq (%rbx), %rdx
subq %rax, %rcx
sarq $0x2, %rcx
xorl %edi, %edi
movq %rdi, %rsi
cmpq %rdi, %rcx
je 0x364f
movl (%rax,%rsi,4), %r8d
leaq 0x1(%rsi), %rdi
cmpl (%rdx,%rsi,4), %r8d
je 0x3639
cmpq %rsi, %rcx
setbe %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/other_fct.cpp
// Function: lcm(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>)
void lcm(vector<int>& u, const vector<int>& LT_f, vector<int>& v, const vector<int> LT_g)
{
  int n = LT_f.size();
  u.assign(n, 0);
  v.assign(n, 0);
  for (int i = 0; i < n; ++i)
    {
      if (LT_f[i] > LT_g[i])
	{
	  v[i] = LT_f[i] - LT_g[i];
	}
      else
	{
	  u[i] = LT_g[i] - LT_f[i];
	}
    }
  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x8(%rsi), %rax
subq (%rsi), %rax
shrq $0x2, %rax
movslq %eax, %r14
leaq 0xc(%rsp), %rdx
andl $0x0, (%rdx)
movq %r14, %rsi
callq 0x41e4
leaq 0x8(%rsp), %rdx
andl $0x0, (%rdx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x41e4
movq (%r12), %rax
movq (%r13), %rcx
movq (%r15), %rdx
xorl %esi, %esi
testl %r14d, %r14d
cmovlel %esi, %r14d
cmpq %rsi, %r14
je 0x36e4
movl (%rax,%rsi,4), %edi
movq (%rbx), %r8
subl (%r8,%rsi,4), %edi
movq %rcx, %r8
cmovgq %rdx, %r8
movl %edi, %r9d
negl %r9d
cmovsl %edi, %r9d
movl %r9d, (%r8,%rsi,4)
incq %rsi
jmp 0x36bb
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/other_fct.cpp
// Function: Create_table(int, int)
vector<pair<term_vec,vector<term_int>>> Create_table(int n, int d)//multiplication table
{
  vector<pair<term_vec,vector<term_int>>> table = {};
  term_int max_size = binom(n+d-1,n)+1;
  table.reserve(max_size);
  term_vec term(n,0);
  vector<term_int> multis(n,0);
  for (int j = 0; j < n; ++j)
    {
      multis[j] = n-j;
    }
  table.emplace_back(make_pair(term,multis));
  for (term_int i = 1; i < max_size; ++i)
    {
      next_term(term);
      for (int j = 1; j <= n; ++j)
	{
	  term_vec term_xj = vector_add(term,j); //new term = term*x_j
	  multis[j-1] = term_to_int(term_xj,n)-1; //might be too slow!,
	  //check for over size!
	}
      table.emplace_back(make_pair(term,multis));
    }
  return table;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leal (%r14,%rdx), %edi
decl %edi
callq 0x32c2
incl %eax
movslq %eax, %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
movq %rsi, 0x28(%rsp)
callq 0x3a94
movslq %r14d, %rbx
leaq 0x50(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rcx
movq %rbx, %rsi
callq 0x39c4
leaq 0x50(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movq %rbx, %rsi
callq 0x3b36
movq 0x10(%rsp), %rax
xorl %ecx, %ecx
testl %r14d, %r14d
movl $0x0, %ebp
cmovgl %r14d, %ebp
cmpq %rcx, %rbp
je 0x37cf
movq %rbx, (%rax,%rcx,8)
incq %rcx
decq %rbx
jmp 0x37be
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x3bc8
leaq 0x50(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x3b8c
leaq 0x50(%rsp), %r12
movq %r12, %rdi
callq 0x2de8
pushq $0x1
popq %rax
leaq 0x38(%rsp), %r13
leaq 0x80(%rsp), %rbx
cmpq 0x28(%rsp), %rax
jge 0x38a7
movq %rax, 0x30(%rsp)
movq %r13, %rdi
callq 0x392b
xorl %r15d, %r15d
cmpq %r15, %rbp
je 0x3875
leal 0x1(%r15), %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x39a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3a1a
movq %rbx, %rdi
movl %r14d, %esi
callq 0x33b4
decq %rax
movq 0x10(%rsp), %rcx
movq %rax, (%rcx,%r15,8)
movq %rbx, %rdi
callq 0x2dfe
movq %r12, %rdi
callq 0x2dfe
incq %r15
jmp 0x382a
movq %r12, %rdi
movq %r13, %rsi
leaq 0x10(%rsp), %rdx
callq 0x3bc8
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x3b8c
movq %r12, %rdi
callq 0x2de8
movq 0x30(%rsp), %rax
incq %rax
jmp 0x380f
leaq 0x10(%rsp), %rdi
callq 0x2d00
leaq 0x38(%rsp), %rdi
callq 0x2dfe
movq 0x8(%rsp), %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x38e2
jmp 0x38f3
movq %rax, %rbx
jmp 0x390f
jmp 0x38dd
movq %rax, %rbx
jmp 0x3919
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2de8
jmp 0x3905
jmp 0x38f3
movq %rax, %rbx
jmp 0x3905
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2dfe
leaq 0x10(%rsp), %rdi
callq 0x2d00
leaq 0x38(%rsp), %rdi
callq 0x2dfe
movq 0x8(%rsp), %rdi
callq 0x2c08
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/other_fct.cpp
// Function: next_term(std::vector<int, std::allocator<int>>&)
void next_term(vector<int>& term) //degree revers lex, change if needed!
{
  //get degree
  int degree = 0;
  for (int i = 0; i < term.size(); ++i)
    {
      degree += term[i];
    }
  if (degree == 0) //term = 1
    {
      term[term.size()-1] = 1; //new term = x_n
      return;
    }
  //get frist non-zero entry which is not x_1
  int non_zero_idx = 0;
  for (int i = 1; i < term.size(); ++i)
    {
      if (term[i] > 0)
	{
	  non_zero_idx = i;
	  break;
	}
    }
  if (non_zero_idx == 0)//term = x_1^degree
    {
      term[0] = 0;
      term[term.size()-1] = degree+1; //new term = x_n^(degree+1)
      return;
    }
  int temp = term[0];
  term[0] = 0;
  term[non_zero_idx] --;
  term[non_zero_idx-1] ++;
  term[non_zero_idx-1] += temp;

      //}

  return;
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
movq %rcx, %rdx
sarq $0x2, %rdx
xorl %edi, %edi
xorl %esi, %esi
cmpq %rdi, %rdx
je 0x394d
addl (%rax,%rdi,4), %esi
incq %rdi
jmp 0x3940
testl %esi, %esi
je 0x3964
pushq $0x1
popq %rdi
cmpq %rdi, %rdx
jbe 0x396d
cmpl $0x0, (%rax,%rdi,4)
jg 0x3977
incq %rdi
jmp 0x3954
movl $0x1, -0x4(%rax,%rcx)
retq
andl $0x0, (%rax)
incl %esi
movl %esi, -0x4(%rax,%rcx)
retq
movl (%rax), %ecx
andl $0x0, (%rax)
movl %edi, %edx
incl %ecx
movd %ecx, %xmm0
movq -0x4(%rax,%rdx,4), %xmm1
movaps 0xb70f(%rip), %xmm2     # 0xf0a0
movss %xmm0, %xmm2            # xmm2 = xmm0[0],xmm2[1,2,3]
paddd %xmm1, %xmm2
movq %xmm2, -0x4(%rax,%rdx,4)
retq
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/lab_poly.cpp
// Function: spol(Lab_poly const&, Lab_poly const&)
Lab_poly spol(const Lab_poly& F, const Lab_poly& G)
{
  pair<int,vector<int>> u,v;
  //cout << "in spol-comp!" << endl;
  lcm(u,F.Get_LM(),v,G.Get_LM());
  return F.Multiply(u.second).Multiply(u.first,true) - G.Multiply(v.second).Multiply(v.first,true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rdx, %r12
movq %rsi, %r13
leaq 0x28(%rsp), %rbx
andl $0x0, -0x8(%rbx)
movq %rdi, %r15
andq $0x0, 0x10(%rbx)
leaq 0x8(%rsp), %r14
andl $0x0, -0x8(%r14)
xorps %xmm0, %xmm0
andq $0x0, 0x10(%r14)
movups %xmm0, (%rbx)
movups %xmm0, (%r14)
movq (%rsi), %rsi
movq (%rdx), %rcx
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xd682
leaq 0xb0(%rsp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x4f34
movl 0x20(%rsp), %edx
leaq 0xe8(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
pushq $0x1
popq %rcx
callq 0x4f96
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x4f34
movl (%rsp), %edx
leaq 0x78(%rsp), %rdi
leaq 0x40(%rsp), %rsi
pushq $0x1
popq %rcx
callq 0x4f96
leaq 0xe8(%rsp), %rsi
leaq 0x78(%rsp), %rdx
movq %r15, %rdi
callq 0x5044
leaq 0x78(%rsp), %rdi
callq 0x2f74
leaq 0x40(%rsp), %rdi
callq 0x2f74
leaq 0xe8(%rsp), %rdi
callq 0x2f74
leaq 0xb0(%rsp), %rdi
callq 0x2f74
movq %r14, %rdi
callq 0x2dfe
movq %rbx, %rdi
callq 0x2dfe
movq %r15, %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
leaq 0x78(%rsp), %rdi
callq 0x2f74
jmp 0x46fd
movq %rax, %r15
leaq 0x40(%rsp), %rdi
callq 0x2f74
jmp 0x470c
movq %rax, %r15
leaq 0xe8(%rsp), %rdi
callq 0x2f74
jmp 0x471e
movq %rax, %r15
leaq 0xb0(%rsp), %rdi
callq 0x2f74
jmp 0x4732
jmp 0x472f
movq %rax, %r15
movq %r14, %rdi
callq 0x2dfe
movq %rbx, %rdi
callq 0x2dfe
movq %r15, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/lab_poly.cpp
// Function: spair(Lab_poly const&, Lab_poly const&)
pair<Lab_poly,Lab_poly> spair(const Lab_poly& F, const Lab_poly& G)
{
  #ifdef Null
  cout << "Spair construction: " << endl;
  cout << "F: " << F << endl;
  cout << "G: " << G << endl;
  #endif
  pair<int,vector<int>> u,v;
  //  monomial u,v;
  lcm(u,F.Get_LM(),v,G.Get_LM());
  //for case p = 2 works, else need coeff!
  #ifdef Null
  cout << "uF: " << F.Multiply(u.second).Multiply(u.first,true);
  cout << "vG:"  << G.Multiply(v.second).Multiply(v.first,true);
  #endif
  return make_pair(F.Multiply(u.second).Multiply(u.first,true),G.Multiply(v.second).Multiply(v.first,true));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rdx, %r12
movq %rsi, %r13
leaq 0x28(%rsp), %rbx
andl $0x0, -0x8(%rbx)
movq %rdi, %r15
andq $0x0, 0x10(%rbx)
leaq 0x8(%rsp), %r14
andl $0x0, -0x8(%r14)
xorps %xmm0, %xmm0
andq $0x0, 0x10(%r14)
movups %xmm0, (%rbx)
movups %xmm0, (%r14)
movq (%rsi), %rsi
movq (%rdx), %rcx
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xd682
leaq 0x78(%rsp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x4f34
movl 0x20(%rsp), %edx
leaq 0xb0(%rsp), %rdi
leaq 0x78(%rsp), %rsi
pushq $0x1
popq %rcx
callq 0x4f96
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x4f34
movl (%rsp), %edx
leaq 0xe8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
pushq $0x1
popq %rcx
callq 0x4f96
leaq 0xb0(%rsp), %r12
leaq 0xe8(%rsp), %r13
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x5f68
movq %r13, %rdi
callq 0x2f74
leaq 0x40(%rsp), %rdi
callq 0x2f74
movq %r12, %rdi
callq 0x2f74
leaq 0x78(%rsp), %rdi
callq 0x2f74
movq %r14, %rdi
callq 0x2dfe
movq %rbx, %rdi
callq 0x2dfe
movq %r15, %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
leaq 0x40(%rsp), %rdi
callq 0x2f74
jmp 0x4866
movq %rax, %r15
leaq 0xb0(%rsp), %rdi
callq 0x2f74
jmp 0x4878
movq %rax, %r15
leaq 0x78(%rsp), %rdi
callq 0x2f74
jmp 0x4889
jmp 0x4886
movq %rax, %r15
movq %r14, %rdi
callq 0x2dfe
movq %rbx, %rdi
callq 0x2dfe
movq %r15, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/lab_poly.cpp
// Function: poly(std::vector<Lab_poly, std::allocator<Lab_poly>> const&)
vector<polynomial> poly(const vector<Lab_poly>& G)
{
  vector<polynomial> basis = {};
  for (int g = 0; g < G.size(); ++g)
    {
      basis.emplace_back(G[g].Get_poly());
    }
  return basis;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %r15d, %r15d
pushq $0x38
popq %r12
xorl %r13d, %r13d
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
cqto
idivq %r12
cmpq %r13, %rax
jbe 0x48ed
addq %r15, %rsi
movq %rbx, %rdi
callq 0x50e2
incq %r13
addq $0x38, %r15
jmp 0x48c5
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2c88
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/./lab_poly.h
// Function: Lab_poly::Multiply(int, bool) const
Lab_poly Multiply(const int t, bool is_constant) const //multiply with constant / term
  {
    if (is_constant) //mutliply with constant
      {
	return Lab_poly(this->_poly.Multiply(t,is_constant),this->_signature);
      }
    else //multiply with term
      {
	return Lab_poly(this->_poly.Multiply(t,is_constant),this->_signature.Multiply(t));
      }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
testl %ecx, %ecx
je 0x4fda
leaq 0x20(%rsp), %r15
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x54e6
movl 0x20(%r12), %edx
movq 0x28(%r12), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4524
jmp 0x500f
leaq 0x20(%r12), %r15
movq %rsp, %r14
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x54e6
movslq %ebp, %rsi
movq %r15, %rdi
callq 0x558a
movq %rdx, %rcx
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x4524
movq %r15, %rdi
callq 0x2f74
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %r14
jmp 0x5034
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f74
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/./lab_poly.h
// Function: Lab_poly::operator-(Lab_poly const&) const
Lab_poly operator-(const Lab_poly& G) const
  {
     
    //create new polynomial poly(F) - poly(G)
    polynomial new_poly = this->_poly - G._poly;
    //create new signature max(S(F),S(G))
    signature new_signature = max(this->_signature,G._signature);
    
    return Lab_poly(new_poly,new_signature);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x56ba
addq $0x20, %r15
addq $0x20, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xebd5
movl (%rax), %ebp
movq 0x8(%rax), %r14
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x57a2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl %ebp, %edx
movq %r14, %rcx
callq 0x4524
leaq 0x8(%rsp), %rdi
callq 0x2f74
leaq 0x28(%rsp), %rdi
callq 0x2f74
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2f74
jmp 0x50cf
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2f74
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/./poly.h
// Function: polynomial::Multiply(std::vector<int, std::allocator<int>> const&) const
polynomial Multiply(const term_vec& t) const//multiply with term t in vector formulation
  {
    vector<monomial> mons = this->_monomials;
    for (int i = 0; i < mons.size(); ++i)
      {
	//cout << "multiplication takes place!" << endl;
	mons[i] = mons[i].Multiply(t); //is_constant
	//determines whether term or constant multiplication
      }
    return polynomial(mons);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x53f8
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
sarq $0x4, %rax
cmpq %r12, %rax
jbe 0x5353
addq %r15, %rdi
movq %r14, %rsi
callq 0x5448
movq (%rsp), %rcx
movq %rax, (%rcx,%r15)
movq %rdx, 0x8(%rcx,%r15)
incq %r12
addq $0x10, %r15
jmp 0x531d
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xd5a4
movq %rsp, %rdi
callq 0x2f74
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x5377
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2f74
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/./signature.h
// Function: signature::Multiply(std::vector<int, std::allocator<int>> const&) const
signature Multiply(const term_vec& t) const//multiply with term t in vector formulation
{
  term_int result = this->_term; //monomial in integer format
  for (int i = 0; i < t.size(); ++i)
	{
	  for (int j = 0; j < t[i]; ++j) //read up from mult table
	    {
	      result = table[result].second[i]; //multiply with x_i+1
	      // cout << "before term" << new_term[i] << endl;
	  //cout << "t[i]" << t[i] << endl;
	  //cout << "after term" << new_term[i] << endl;
	    }
	}
  return signature(result,this->_index);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rax
movq 0x8(%rdi), %rsi
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
sarq $0x2, %rax
leaq 0x12dc5(%rip), %rdx     # 0x18170
movq (%rdx), %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq %rax, %r9
je 0x53de
movl (%rcx,%r9,4), %r10d
testl %r10d, %r10d
cmovlel %r8d, %r10d
subl $0x1, %r10d
jb 0x53d9
imulq $0x30, %rsi, %rsi
movq 0x18(%rdx,%rsi), %rsi
movq (%rsi,%r9,8), %rsi
jmp 0x53c4
incq %r9
jmp 0x53b4
movl (%rdi), %edx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xebbe
movl (%rbx), %eax
movq 0x8(%rbx), %rdx
addq $0x10, %rsp
popq %rbx
retq
nop