LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tanakh[P]icfpc2015/main.cpp
// Function: init_genrand(unsigned long)
void init_genrand(unsigned long s)
{
    mt[0]= s & 0xffffffffUL;
    for (mti=1; mti<N; mti++) {
        mt[mti] =
            (1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti);
        /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
        /* In the previous versions, MSBs of the seed affect   */
        /* only MSBs of the array mt[].                        */
        /* 2002/01/09 modified by Makoto Matsumoto             */
        mt[mti] &= 0xffffffffUL;
        /* for >32 bit machines */
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq -0x8(%rsp), %rax
movq %rax, 0x45a75(%rip)     # 0x4a3e0
movl $0x1, 0x45a1b(%rip)     # 0x4a390
cmpl $0x270, 0x45a11(%rip)   # imm = 0x270
jge 0x4a18
movl 0x45a05(%rip), %eax     # 0x4a390
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x45a48(%rip), %rax     # 0x4a3e0
movq (%rax,%rcx,8), %rax
movl 0x459ee(%rip), %ecx     # 0x4a390
subl $0x1, %ecx
movslq %ecx, %rdx
leaq 0x45a31(%rip), %rcx     # 0x4a3e0
movq (%rcx,%rdx,8), %rcx
shrq $0x1e, %rcx
xorq %rcx, %rax
imulq $0x6c078965, %rax, %rdx # imm = 0x6C078965
movslq 0x459c8(%rip), %rax     # 0x4a390
addq %rax, %rdx
movslq 0x459be(%rip), %rcx     # 0x4a390
leaq 0x45a07(%rip), %rax     # 0x4a3e0
movq %rdx, (%rax,%rcx,8)
movslq 0x459ac(%rip), %rcx     # 0x4a390
leaq 0x459f5(%rip), %rax     # 0x4a3e0
movabsq $0xffffffff, %rdx       # imm = 0xFFFFFFFF
andq (%rax,%rcx,8), %rdx
leaq 0x459e0(%rip), %rax     # 0x4a3e0
movq %rdx, (%rax,%rcx,8)
movl 0x45986(%rip), %eax     # 0x4a390
addl $0x1, %eax
movl %eax, 0x4597d(%rip)     # 0x4a390
jmp 0x4975
retq
nopl (%rax)
// File: tanakh[P]icfpc2015/main.cpp
// Function: operator<<(std::ostream&, unit const&)
ostream &operator<<(ostream &os, const unit &u)
{
  os << "{ " << u.pivot << ", [";
  for (auto &i: u.members)
    os << i << ", ";
  os << "] }";
  return os;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x3137e(%rip), %rsi     # 0x36408
callq 0x43c0
movq %rax, %rdi
movq 0x28(%rsp), %rsi
addq $0x18, %rsi
callq 0x10e40
movq %rax, %rdi
leaq 0x31361(%rip), %rsi     # 0x3640b
callq 0x43c0
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x110b0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x110e0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x11110
testb $0x1, %al
jne 0x50ec
jmp 0x5125
leaq 0x18(%rsp), %rdi
callq 0x11150
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x10e40
movq %rax, %rdi
leaq 0x312fb(%rip), %rsi     # 0x3640f
callq 0x43c0
leaq 0x18(%rsp), %rdi
callq 0x11160
jmp 0x50d7
movq 0x30(%rsp), %rdi
leaq 0x312e1(%rip), %rsi     # 0x36412
callq 0x43c0
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
// File: tanakh[P]icfpc2015/main.cpp
// Function: read_problem(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
problem read_problem(const string &file)
{
  ifstream ifs(file.c_str());
  value v;
  parse(v, ifs);
  return to_problem(v);
}

// Assembly:
subq $0x268, %rsp            # imm = 0x268
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq 0x258(%rsp), %rdi
callq 0x4130
movq %rax, %rsi
leaq 0x50(%rsp), %rdi
movl $0x8, %edx
callq 0x4680
leaq 0x40(%rsp), %rdi
callq 0x11bb0
jmp 0x664e
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x11bd0
jmp 0x6664
leaq 0x10(%rsp), %rdi
callq 0x4700
movq (%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x5cd0
jmp 0x667e
leaq 0x40(%rsp), %rdi
callq 0x11ce0
leaq 0x50(%rsp), %rdi
callq 0x40b0
movq 0x8(%rsp), %rax
addq $0x268, %rsp            # imm = 0x268
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x66c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x11ce0
leaq 0x50(%rsp), %rdi
callq 0x40b0
movq 0x38(%rsp), %rdi
callq 0x4620
nopl (%rax,%rax)
// File: tanakh[P]icfpc2015/main.cpp
// Function: to_char(command)
char to_char(command m) {
  switch (m) {
  case W:   return "p'!.03"[genrand_int31()%1];
  case E:   return "bcefy2"[genrand_int31()%5];
  case SW:  return "aghij4"[genrand_int31()%5];
  case SE:  return "lmno 5"[genrand_int31()%4];
  case CW:  return "dqrvz1"[genrand_int31()%5];
  case CCW: return "kstuwx"[genrand_int31()%6];
  }
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq %rax, 0x8(%rsp)
subq $0x5, %rax
ja 0x67cd
movq 0x8(%rsp), %rax
leaq 0x2f9a9(%rip), %rcx     # 0x360b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x4ed0
movl $0x1, %ecx
cqto
idivq %rcx
leaq 0x2fd74(%rip), %rax     # 0x3649a
movb (%rax,%rdx), %al
movb %al, 0x17(%rsp)
jmp 0x67cf
callq 0x4ed0
movl $0x5, %ecx
cqto
idivq %rcx
leaq 0x2fd59(%rip), %rax     # 0x364a1
movb (%rax,%rdx), %al
movb %al, 0x17(%rsp)
jmp 0x67cf
callq 0x4ed0
movl $0x5, %ecx
cqto
idivq %rcx
leaq 0x2fd41(%rip), %rax     # 0x364a8
movb (%rax,%rdx), %al
movb %al, 0x17(%rsp)
jmp 0x67cf
callq 0x4ed0
movl $0x4, %ecx
cqto
idivq %rcx
leaq 0x2fd29(%rip), %rax     # 0x364af
movb (%rax,%rdx), %al
movb %al, 0x17(%rsp)
jmp 0x67cf
callq 0x4ed0
movl $0x5, %ecx
cqto
idivq %rcx
leaq 0x2fd11(%rip), %rax     # 0x364b6
movb (%rax,%rdx), %al
movb %al, 0x17(%rsp)
jmp 0x67cf
callq 0x4ed0
movl $0x6, %ecx
cqto
idivq %rcx
leaq 0x2fcf9(%rip), %rax     # 0x364bd
movb (%rax,%rdx), %al
movb %al, 0x17(%rsp)
jmp 0x67cf
ud2
movb 0x17(%rsp), %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: tanakh[P]icfpc2015/main.cpp
// Function: show_command[abi:cxx11](command)
string show_command(command m) {
  switch (m) {
  case W:   return "W";
  case E:   return "E";
  case SW:  return "SW";
  case SE:  return "SE";
  case CW:  return "CW";
  case CCW: return "CCW";
  }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
movq %rax, 0x48(%rsp)
subq $0x5, %rax
ja 0x6a08
movq 0x48(%rsp), %rax
leaq 0x2f8af(%rip), %rcx     # 0x360c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x6b(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x4630
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rdx
leaq 0x2fc8a(%rip), %rsi     # 0x364cc
callq 0x44f0
jmp 0x6849
leaq 0x6b(%rsp), %rdi
callq 0x4430
jmp 0x6a0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x6b(%rsp), %rdi
callq 0x4430
jmp 0x6a14
leaq 0x5b(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x4630
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rdx
leaq 0x2fc33(%rip), %rsi     # 0x364c8
callq 0x44f0
jmp 0x689c
leaq 0x5b(%rsp), %rdi
callq 0x4430
jmp 0x6a0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x5b(%rsp), %rdi
callq 0x4430
jmp 0x6a14
leaq 0x5a(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x4630
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0x2fbdc(%rip), %rsi     # 0x364c4
callq 0x44f0
jmp 0x68ef
leaq 0x5a(%rsp), %rdi
callq 0x4430
jmp 0x6a0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x5a(%rsp), %rdi
callq 0x4430
jmp 0x6a14
leaq 0x59(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x4630
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x2fb8c(%rip), %rsi     # 0x364c7
callq 0x44f0
jmp 0x6942
leaq 0x59(%rsp), %rdi
callq 0x4430
jmp 0x6a0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x59(%rsp), %rdi
callq 0x4430
jmp 0x6a14
leaq 0x58(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4630
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x2fb3d(%rip), %rsi     # 0x364cb
callq 0x44f0
jmp 0x6995
leaq 0x58(%rsp), %rdi
callq 0x4430
jmp 0x6a0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x4430
jmp 0x6a14
leaq 0x57(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4630
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x2faef(%rip), %rsi     # 0x364ca
callq 0x44f0
jmp 0x69e2
leaq 0x57(%rsp), %rdi
callq 0x4430
jmp 0x6a0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x57(%rsp), %rdi
callq 0x4430
jmp 0x6a14
ud2
movq 0x40(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x4620
nop
// File: tanakh[P]icfpc2015/main.cpp
// Function: check(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>> const&, std::complex<int> const&, unit const&, int)
bool check(const vector<vector<int>> &bd, const pt &pos, const unit &u, int rot)
{
  for (auto &c: u.members)
    if (!check_one(bd, pos, u.pivot, c, rot))
      return false;
  return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x110b0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x110e0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x11110
testb $0x1, %al
jne 0x6eb4
jmp 0x6efc
leaq 0x10(%rsp), %rdi
callq 0x11150
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq $0x18, %rdx
movq (%rsp), %rcx
movl 0x24(%rsp), %r8d
callq 0x11fc0
testb $0x1, %al
jne 0x6eee
movb $0x0, 0x47(%rsp)
jmp 0x6f01
jmp 0x6ef0
leaq 0x10(%rsp), %rdi
callq 0x11160
jmp 0x6e9f
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x12210
movq %rax, %rdi
callq 0x12180
shrq %rax
movl %eax, 0x3c(%rsp)
movq 0x40(%rsp), %rdi
callq 0x12140
movl %eax, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x38(%rsp), %eax
jge 0x760b
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x75e7
movl 0x30(%rsp), %eax
shll %eax
movl %eax, 0x28(%rsp)
movl 0x34(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl 0x28(%rsp), %eax
addl %edx, %eax
movl %eax, 0x2c(%rsp)
movl 0x34(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x1, %edx
jne 0x74e5
callq 0x5040
movq %rax, %rdi
leaq 0x2f151(%rip), %rsi     # 0x36631
callq 0x43c0
callq 0x5040
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movslq 0x34(%rsp), %rsi
callq 0x12210
movq %rax, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x12230
cmpl $0x1, (%rax)
jne 0x7521
leaq 0x2f057(%rip), %rax     # 0x3656e
movq %rax, 0x18(%rsp)
jmp 0x75a1
movq 0x40(%rsp), %rdi
movslq 0x34(%rsp), %rsi
callq 0x12210
movq %rax, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x12230
cmpl $0x2, (%rax)
jne 0x7550
leaq 0x2f027(%rip), %rax     # 0x36570
movq %rax, 0x10(%rsp)
jmp 0x7597
movq 0x40(%rsp), %rdi
movslq 0x34(%rsp), %rsi
callq 0x12210
movq %rax, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x12230
cmpl $0x3, (%rax)
jne 0x757f
leaq 0x2effa(%rip), %rax     # 0x36572
movq %rax, 0x8(%rsp)
jmp 0x758d
leaq 0x2f1d8(%rip), %rax     # 0x3675e
movq %rax, 0x8(%rsp)
jmp 0x758d
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x43c0
movl 0x34(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x75d5
callq 0x5040
movq %rax, %rdi
leaq 0x2f061(%rip), %rsi     # 0x36631
callq 0x43c0
jmp 0x75d7
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x7492
callq 0x5040
movq %rax, %rdi
movq 0x4299a(%rip), %rsi     # 0x49f90
callq 0x4400
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x747c
callq 0x5040
movq %rax, %rdi
movq 0x42976(%rip), %rsi     # 0x49f90
callq 0x4400
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tanakh[P]icfpc2015/main.cpp
// Function: get_init_pos(problem const&, unit const&)
pt get_init_pos(const problem &prob, const unit &u)
{
  int maxx = -0x7fffffff, minx = 0x7fffffff, miny = 0x7fffffff;

  for (auto &p: u.members) {
    maxx = max(maxx, p.real()/2);
    minx = min(minx, p.real()/2);
    miny = min(miny, p.imag());
  }

  int py = -miny;
  int px = (prob.width - (maxx - minx + 1)) / 2 - minx;

  return pt(px*2+(py%2+2)%2, py);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movl $0x80000001, 0x4c(%rsp) # imm = 0x80000001
movl $0x7fffffff, 0x48(%rsp) # imm = 0x7FFFFFFF
movl $0x7fffffff, 0x44(%rsp) # imm = 0x7FFFFFFF
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x110b0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x110e0
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x11110
testb $0x1, %al
jne 0x7a76
jmp 0x7b0d
leaq 0x30(%rsp), %rdi
callq 0x11150
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11920
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x1c(%rsp)
leaq 0x4c(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x123b0
movl (%rax), %eax
movl %eax, 0x4c(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11920
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x11a30
movl (%rax), %eax
movl %eax, 0x48(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11930
movl %eax, 0x14(%rsp)
leaq 0x44(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x11a30
movl (%rax), %eax
movl %eax, 0x44(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11160
jmp 0x7a5e
xorl %eax, %eax
subl 0x44(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x58(%rsp), %rax
movl 0x20(%rax), %eax
movl 0x4c(%rsp), %ecx
subl 0x48(%rsp), %ecx
addl $0x1, %ecx
subl %ecx, %eax
movl $0x2, %ecx
cltd
idivl %ecx
subl 0x48(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
shll %eax
movl %eax, 0x4(%rsp)
movl 0x10(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %edx, %eax
addl $0x2, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl 0x4(%rsp), %eax
addl %edx, %eax
movl %eax, 0x8(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x11530
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movb $0x0, 0x77(%rsp)
callq 0x4500
movl $0x0, 0x70(%rsp)
movl 0x70(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x78(%rsp), %rdi
callq 0x12180
movq %rax, %rcx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jge 0x8a1e
movb $0x0, 0x6f(%rsp)
leaq 0x42ee0(%rip), %rax     # 0x4b760
movq %rax, 0x60(%rsp)
leaq 0x42ed4(%rip), %rdi     # 0x4b760
callq 0x125c0
movq %rax, 0x58(%rsp)
leaq 0x42ec3(%rip), %rdi     # 0x4b760
callq 0x125f0
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x12620
testb $0x1, %al
jne 0x88bf
jmp 0x89e2
leaq 0x58(%rsp), %rdi
callq 0x12640
movq %rax, 0x48(%rsp)
movb $0x1, 0x47(%rsp)
movl $0x0, 0x40(%rsp)
movl 0x40(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4270
movq %rax, %rcx
movl 0x18(%rsp), %eax
cmpl %ecx, %eax
jge 0x8999
movl 0x70(%rsp), %eax
addl 0x40(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x78(%rsp), %rdi
callq 0x12180
movq %rax, %rcx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x8963
movq 0x78(%rsp), %rdi
movl 0x70(%rsp), %eax
movl 0x40(%rsp), %ecx
addl %ecx, %eax
movslq %eax, %rsi
callq 0x12230
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x48(%rsp), %rdi
movslq 0x40(%rsp), %rsi
callq 0x4460
movsbl (%rax), %edi
callq 0x6a20
movl %eax, 0x10(%rsp)
jmp 0x8957
movl 0xc(%rsp), %eax
movl 0x10(%rsp), %ecx
cmpl %ecx, %eax
je 0x8987
movb $0x0, 0x47(%rsp)
jmp 0x8999
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x4700
jmp 0x8a41
jmp 0x8989
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x88db
testb $0x1, 0x47(%rsp)
je 0x89d1
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x44b0
jmp 0x89b1
movq 0x48(%rsp), %rdi
callq 0x4270
movq %rax, %rcx
movslq 0x70(%rsp), %rax
addq %rcx, %rax
movl %eax, 0x70(%rsp)
movb $0x1, 0x6f(%rsp)
jmp 0x89e2
jmp 0x89d3
leaq 0x58(%rsp), %rdi
callq 0x12670
jmp 0x88a7
testb $0x1, 0x6f(%rsp)
jne 0x8a19
movq 0x78(%rsp), %rdi
movslq 0x70(%rsp), %rsi
callq 0x12230
movl (%rax), %edi
callq 0x66e0
movq 0x20(%rsp), %rdi
movsbl %al, %esi
callq 0x4220
jmp 0x8a0e
movl 0x70(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x70(%rsp)
jmp 0x8853
movb $0x1, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
jne 0x8a34
movq 0x20(%rsp), %rdi
callq 0x4700
movq 0x28(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x4620
nopl (%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movb $0x0, 0xa7(%rsp)
movq 0xa8(%rsp), %rax
movslq 0x24(%rax), %rcx
movq %rcx, 0x30(%rsp)
movl 0x20(%rax), %eax
addl %eax, %eax
cltq
movq %rax, 0x38(%rsp)
movl $0x1, 0x84(%rsp)
leaq 0x83(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x13020
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rcx
leaq 0x88(%rsp), %rdi
leaq 0x84(%rsp), %rdx
callq 0x13030
jmp 0x9737
leaq 0x73(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x130b0
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rcx
leaq 0x88(%rsp), %rdx
callq 0x130c0
jmp 0x9764
leaq 0x73(%rsp), %rdi
callq 0x13140
leaq 0x88(%rsp), %rdi
callq 0x13150
leaq 0x83(%rsp), %rdi
callq 0x131b0
movl $0x0, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
movq 0xa8(%rsp), %rcx
cmpl 0x24(%rcx), %eax
jge 0x9864
movl $0x0, 0x68(%rsp)
movl 0x68(%rsp), %eax
movq 0xa8(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x9852
movq 0x20(%rsp), %rdi
movslq 0x6c(%rsp), %rsi
callq 0x12160
movq %rax, %rdi
movl 0x68(%rsp), %eax
shll %eax
movl %eax, 0x14(%rsp)
movl 0x6c(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl 0x14(%rsp), %eax
addl %edx, %eax
movslq %eax, %rsi
callq 0x121a0
movl $0x0, (%rax)
movl 0x68(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x68(%rsp)
jmp 0x97ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x9840
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x73(%rsp), %rdi
callq 0x13140
leaq 0x88(%rsp), %rdi
callq 0x13150
leaq 0x83(%rsp), %rdi
callq 0x131b0
jmp 0x9954
jmp 0x9854
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x9790
movq 0xa8(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x110b0
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x110e0
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x11110
testb $0x1, %al
jne 0x98ab
jmp 0x992b
leaq 0x58(%rsp), %rdi
callq 0x11150
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x11930
movl %eax, 0x10(%rsp)
jmp 0x98ca
movq 0x20(%rsp), %rdi
movl 0x10(%rsp), %eax
movslq %eax, %rsi
callq 0x12160
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
callq 0x11920
movl %eax, 0xc(%rsp)
jmp 0x98ef
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movslq %eax, %rsi
callq 0x121a0
movl $0x1, (%rax)
leaq 0x58(%rsp), %rdi
callq 0x11160
jmp 0x9893
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
callq 0x12350
jmp 0x9954
movb $0x1, 0xa7(%rsp)
testb $0x1, 0xa7(%rsp)
jne 0x9947
movq 0x20(%rsp), %rdi
callq 0x12350
movq 0x28(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x4620
nop
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xa0(%rsp)
movb $0x0, 0x9f(%rsp)
callq 0x131c0
leaq 0x80(%rsp), %rdi
callq 0x131d0
leaq 0x41dc3(%rip), %rax     # 0x4b760
movq %rax, 0x78(%rsp)
leaq 0x41db7(%rip), %rdi     # 0x4b760
callq 0x125c0
movq %rax, 0x70(%rsp)
leaq 0x41da6(%rip), %rdi     # 0x4b760
callq 0x125f0
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x12620
testb $0x1, %al
jne 0x99d9
jmp 0x9a4b
leaq 0x70(%rsp), %rdi
callq 0x12640
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x4570
negq %rax
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdx
leaq 0x80(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x131e0
jmp 0x9a13
jmp 0x9a15
leaq 0x70(%rsp), %rdi
callq 0x12670
jmp 0x99c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x133e0
movq 0x8(%rsp), %rdi
callq 0x13440
jmp 0x9b28
leaq 0x80(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x132a0
movq (%rsp), %rdi
movq %rax, 0x40(%rsp)
callq 0x132d0
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x13260
jmp 0x9a80
leaq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x132a0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x132d0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x13300
testb $0x1, %al
jne 0x9ac0
jmp 0x9af2
leaq 0x28(%rsp), %rdi
callq 0x13340
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
addq $0x8, %rsi
callq 0x13350
jmp 0x9ae4
jmp 0x9ae6
leaq 0x28(%rsp), %rdi
callq 0x133c0
jmp 0x9aab
leaq 0x80(%rsp), %rdi
callq 0x133e0
movb $0x1, 0x9f(%rsp)
testb $0x1, 0x9f(%rsp)
jne 0x9b1b
movq 0x8(%rsp), %rdi
callq 0x13440
movq 0x10(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x4620
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl $0x0, 0x7c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x9960
leaq 0x60(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x134a0
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x134d0
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x13500
testb $0x1, %al
jne 0x9ba1
jmp 0x9d2b
leaq 0x50(%rsp), %rdi
callq 0x13540
movq %rax, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movl $0x0, 0x38(%rsp)
movl 0x38(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x80(%rsp), %rdi
callq 0x4270
movq %rax, %rcx
movl 0x20(%rsp), %eax
cmpl %ecx, %eax
jge 0x9ce3
movb $0x1, 0x37(%rsp)
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x40(%rsp), %rdi
callq 0x4270
movq %rax, %rcx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jge 0x9cbf
movl 0x38(%rsp), %eax
addl 0x30(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x80(%rsp), %rdi
callq 0x4270
movq %rax, %rcx
movl 0x18(%rsp), %eax
cmpl %ecx, %eax
jge 0x9c89
movq 0x80(%rsp), %rdi
movl 0x38(%rsp), %eax
movl 0x30(%rsp), %ecx
addl %ecx, %eax
movslq %eax, %rsi
callq 0x4460
movsbl (%rax), %edi
callq 0x4530
movl %eax, 0xc(%rsp)
movq 0x40(%rsp), %rdi
movslq 0x30(%rsp), %rsi
callq 0x46e0
movq %rax, 0x10(%rsp)
jmp 0x9c72
movq 0x10(%rsp), %rax
movsbl (%rax), %edi
callq 0x4530
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
je 0x9cad
movb $0x0, 0x37(%rsp)
jmp 0x9cbf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x13440
jmp 0x9d49
jmp 0x9caf
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x9bf1
testb $0x1, 0x37(%rsp)
je 0x9cd1
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x9cd3
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x9bc0
cmpl $0x0, 0x3c(%rsp)
jle 0x9cf7
movl 0x7c(%rsp), %eax
addl $0x12c, %eax            # imm = 0x12C
movl %eax, 0x7c(%rsp)
movq 0x40(%rsp), %rdi
callq 0x4570
movq %rax, %rcx
shlq %rcx
movslq 0x3c(%rsp), %rax
imulq %rax, %rcx
movslq 0x7c(%rsp), %rax
addq %rcx, %rax
movl %eax, 0x7c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x13550
jmp 0x9b89
movl 0x7c(%rsp), %eax
movl %eax, 0x8(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x13440
movl 0x8(%rsp), %eax
addq $0x88, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x4620
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x50(%rsp)
movq %rdi, %rax
movq %rax, 0x58(%rsp)
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movl %ecx, 0x10c(%rsp)
leaq 0xd8(%rsp), %rdi
callq 0x11770
movq 0x118(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq 0xd0(%rsp), %rdi
callq 0x110b0
movq %rax, 0xc8(%rsp)
movq 0xd0(%rsp), %rdi
callq 0x110e0
movq %rax, 0xc0(%rsp)
leaq 0xc8(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x11110
testb $0x1, %al
jne 0xa4b8
jmp 0xa61f
leaq 0xc8(%rsp), %rdi
callq 0x11150
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rdi
movq 0x110(%rsp), %rsi
callq 0x12100
movq %rax, 0x48(%rsp)
jmp 0xa4e9
movq 0x48(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x118(%rsp), %rdi
addq $0x18, %rdi
movq 0x110(%rsp), %rsi
callq 0x12100
movq %rax, 0x40(%rsp)
jmp 0xa516
movq 0x40(%rsp), %rax
movq %rax, 0x94(%rsp)
movl 0x10c(%rsp), %edx
leaq 0xa8(%rsp), %rdi
leaq 0x94(%rsp), %rsi
callq 0x11830
movq %rax, 0x38(%rsp)
jmp 0xa546
movq 0x38(%rsp), %rax
movq %rax, 0xb0(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x11920
movl %eax, 0x34(%rsp)
jmp 0xa566
movl 0x34(%rsp), %eax
movl %eax, 0x88(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x11930
movl %eax, 0x30(%rsp)
jmp 0xa584
movl 0x30(%rsp), %eax
movl %eax, 0x84(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x84(%rsp), %rsi
callq 0x118f0
movq %rax, 0x28(%rsp)
jmp 0xa5ab
movq 0x28(%rsp), %rax
movq %rax, 0x8c(%rsp)
leaq 0xd8(%rsp), %rdi
leaq 0x8c(%rsp), %rsi
callq 0x11890
movb %dl, 0x1f(%rsp)
movq %rax, 0x20(%rsp)
jmp 0xa5d8
movb 0x1f(%rsp), %al
movq 0x20(%rsp), %rcx
movq %rcx, 0x70(%rsp)
movb %al, 0x78(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0x11160
jmp 0xa49a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0xd8(%rsp), %rdi
callq 0x11a20
jmp 0xa697
movq 0x118(%rsp), %rdi
addq $0x18, %rdi
movq 0x110(%rsp), %rsi
callq 0x12100
movq %rax, 0x10(%rsp)
jmp 0xa63f
movq 0x10(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x137d0
movq %rax, 0x8(%rsp)
jmp 0xa65a
movq 0x50(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x68(%rsp), %rsi
leaq 0xd8(%rsp), %rdx
callq 0x13790
jmp 0xa67d
leaq 0xd8(%rsp), %rdi
callq 0x11a20
movq 0x58(%rsp), %rax
addq $0x128, %rsp            # imm = 0x128
retq
movq 0xa0(%rsp), %rdi
callq 0x4620
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0x14650
movq %rax, 0x60(%rsp)
movq 0x68(%rsp), %rdi
callq 0x14680
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x146b0
testb $0x1, %al
jne 0xc987
jmp 0xc9c6
leaq 0x60(%rsp), %rdi
callq 0x146f0
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
cvtsi2sdl (%rax), %xmm0
callq 0x4300
movl $0x2, %edi
callq 0x14700
addsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x70(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x14730
jmp 0xc972
movq 0x78(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x14650
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x14680
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x146b0
testb $0x1, %al
jne 0xca06
jmp 0xca87
leaq 0x40(%rsp), %rdi
callq 0x146f0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
cvtsi2sdl (%rax), %xmm0
callq 0x4300
movl $0x2, %edi
callq 0x14700
movsd %xmm0, 0x28(%rsp)
callq 0x4ee0
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
divsd 0x70(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xca62
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x28, %rsi
callq 0x14500
jmp 0xcad0
movsd 0x28(%rsp), %xmm1
movsd 0x70(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x14730
jmp 0xc9ee
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x4ed0
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rdi
callq 0x14770
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rsi
callq 0x14750
movq 0x18(%rsp), %rdi
movq %rax, %rsi
addq $0x28, %rsi
callq 0x14500
movq 0x20(%rsp), %rax
addq $0x88, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq 0x38(%rsp), %rax
je 0x1360a
movq 0x38(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x16e80
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1aff0
jmp 0x135e4
leaq 0x28(%rsp), %rdi
callq 0x11ce0
jmp 0x1360a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x11ce0
jmp 0x13614
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x4620
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x24(%rax)
je 0x185e9
movq (%rsp), %rax
movb $0x0, 0x24(%rax)
movl 0x20(%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x18653
movq (%rsp), %rdi
movq %rdi, %rsi
addq $0x10, %rsi
callq 0x1a800
testb $0x1, %al
jne 0x185ff
jmp 0x18614
movq (%rsp), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x18653
movq (%rsp), %rax
cmpl $0xa, 0x20(%rax)
jne 0x1862b
movq (%rsp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movq (%rsp), %rdi
callq 0x1a830
movq (%rsp), %rdi
movsbl %al, %eax
andl $0xff, %eax
movl %eax, 0x20(%rdi)
callq 0x1a860
movq (%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: manschga[P]M5GB/other_fct.cpp
// Function: term_is_Zero(std::vector<int, std::allocator<int>>)
bool term_is_Zero(vector<int> term)
{
  for (int i = 0; i < term.size(); ++i)
    {
      if (term[i] > 0)
	{
	  return false;
	}
    }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x3260
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x4ed9
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3280
cmpl $0x0, (%rax)
jle 0x4ecc
movb $0x0, -0x1(%rbp)
jmp 0x4edd
jmp 0x4ece
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4e97
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3260
subq $0x1, %rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x4f39
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x5fd0
cmpl $0x0, (%rax)
jle 0x4f2c
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4f62
jmp 0x4f2e
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4f0c
movq 0x3b098(%rip), %rdi     # 0x3ffd8
leaq 0x26140(%rip), %rsi     # 0x2b087
callq 0x2190
movq %rax, %rdi
movq 0x3b072(%rip), %rsi     # 0x3ffc8
callq 0x21d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x5ff0
movq -0x10(%rbp), %rdi
callq 0x4ef0
movl %eax, -0x28(%rbp)
jmp 0x4fa6
movq -0x38(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, -0x18(%rbp)
movslq -0x18(%rbp), %rsi
callq 0x3280
movl $0x0, (%rax)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4feb
jmp 0x4fe2
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3b70
jmp 0x4ff5
movq -0x38(%rbp), %rdi
callq 0x3b70
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2300
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x5045
movq 0x3afb7(%rip), %rdi     # 0x3ffd8
leaq 0x26070(%rip), %rsi     # 0x2b098
callq 0x2190
movq %rax, %rdi
movq 0x3af91(%rip), %rsi     # 0x3ffc8
callq 0x21d0
movl $0x0, -0x4(%rbp)
jmp 0x50a5
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x507c
cmpl $0x1, -0x8(%rbp)
jne 0x5062
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x50a5
movl -0x8(%rbp), %eax
addl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %edx, -0x8(%rbp)
jmp 0x5071
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x504c
movq 0x3af55(%rip), %rdi     # 0x3ffd8
leaq 0x26032(%rip), %rsi     # 0x2b0bc
callq 0x2190
movq %rax, %rdi
movq 0x3af2f(%rip), %rsi     # 0x3ffc8
callq 0x21d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x50cb
movl $0x0, -0x4(%rbp)
jmp 0x5139
cmpl $0x0, -0xc(%rbp)
jl 0x50d7
cmpl $0x0, -0x8(%rbp)
jge 0x50e0
movl $0x0, -0x4(%rbp)
jmp 0x5139
movl $0x1, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl -0x8(%rbp), %ecx
subl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jle 0x50fd
movl -0x8(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5133
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
imull -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movl -0x10(%rbp), %eax
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5104
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x20e0
movq -0x58(%rbp), %rdi
callq 0x5ed0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x5224
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20e0
leaq -0x30(%rbp), %rdi
callq 0x60e0
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x51fe
movl -0x18(%rbp), %edi
movl -0x34(%rbp), %esi
callq 0x50b0
cltq
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6100
jmp 0x51d1
jmp 0x51d3
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x51a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3490
movq -0x58(%rbp), %rdi
callq 0x2fb0
jmp 0x5241
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6130
jmp 0x520d
leaq -0x30(%rbp), %rdi
callq 0x3490
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x517d
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x5237
movq -0x58(%rbp), %rdi
callq 0x2fb0
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2300
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x3260
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x52ae
movq -0x28(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3280
movl (%rax), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5271
movl $0x0, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
cmpl $0x0, %eax
jle 0x52f1
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
leaq 0x3af25(%rip), %rdi     # 0x401f8
callq 0x61a0
movq %rax, %rdi
movslq -0xc(%rbp), %rsi
callq 0x61c0
movq (%rax), %rcx
movslq -0x18(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x5374
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x3280
movl (%rax), %ecx
movl -0x10(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl -0x10(%rbp), %eax
cmpl $0x0, %eax
jle 0x5367
cmpl $0x0, -0x10(%rbp)
jle 0x5367
movl -0x1c(%rbp), %eax
addl -0x10(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
leaq 0x3aeb4(%rip), %rdi     # 0x401f8
callq 0x61a0
movq %rax, %rdi
movl -0x10(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x61c0
movq (%rax), %rcx
movslq -0x18(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x18(%rbp)
jmp 0x5369
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5303
movslq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x20e0
movq -0x38(%rbp), %rdi
callq 0x61e0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x540e
movl -0x18(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x5440
movl %eax, -0x44(%rbp)
jmp 0x53d5
movq -0x38(%rbp), %rdi
movl -0x44(%rbp), %eax
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x6200
jmp 0x53ea
jmp 0x53ec
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x53bd
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3b70
jmp 0x542b
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x5421
movq -0x38(%rbp), %rdi
callq 0x3b70
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2300
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x5486
movl -0x8(%rbp), %edi
addl -0x10(%rbp), %edi
subl $0x1, %edi
movl -0x10(%rbp), %esi
callq 0x50b0
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x545c
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3260
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3260
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0x56d4
movq 0x3a91f(%rip), %rdi     # 0x3ffd8
leaq 0x25a5e(%rip), %rsi     # 0x2b11e
callq 0x2190
movq %rax, %rdi
movq 0x3a8f9(%rip), %rsi     # 0x3ffc8
callq 0x21d0
movq -0x10(%rbp), %rdi
callq 0x3260
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3260
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x5740
movq -0x10(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x5fd0
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x5fd0
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl (%rcx), %eax
je 0x5733
movb $0x0, -0x1(%rbp)
jmp 0x5744
jmp 0x5735
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x56e7
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rcx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3260
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x24(%rbp), %rsi
movl $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rdx
callq 0x6230
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rsi
movl $0x0, -0x2c(%rbp)
leaq -0x2c(%rbp), %rdx
callq 0x6230
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x586e
movq -0x10(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x5fd0
movq -0x38(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movslq -0x30(%rbp), %rsi
callq 0x5fd0
movq %rax, %rcx
movl -0x3c(%rbp), %eax
cmpl (%rcx), %eax
jle 0x5822
movq -0x10(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x5fd0
movq -0x38(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movslq -0x30(%rbp), %rsi
callq 0x5fd0
movq %rax, %rcx
movl -0x44(%rbp), %eax
subl (%rcx), %eax
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x3280
movl -0x40(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x585e
movq -0x38(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x5fd0
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x5fd0
movq %rax, %rcx
movl -0x4c(%rbp), %eax
subl (%rcx), %eax
movl %eax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x30(%rbp), %rsi
callq 0x3280
movl -0x48(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x5860
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x57af
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)