LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 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
movq %rdi, %rbx
movslq %r13d, %r12
leaq 0x4(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x3(%rsp), %rcx
movq %r12, %rsi
callq 0x3fe0
testl %r12d, %r12d
jle 0x32ba
movq (%r15), %rcx
movq (%r14), %rsi
movq (%rbx), %rdi
movl %r13d, %r8d
andl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
xorl %r9d, %r9d
movl (%rcx,%r9,4), %eax
addl %ebp, %eax
subl (%rsi,%r9,4), %eax
cltd
idivl %ebp
movl %edx, (%rdi,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x32a1
movq (%r15), %rax
movq 0x8(%r15), %rsi
subq %rax, %rsi
movq (%r14), %rcx
movq 0x8(%r14), %rdi
subq %rcx, %rdi
movq %rdi, %rdx
shrq $0x2, %rdx
cmpq %rdi, %rsi
jbe 0x32f8
cmpl %r13d, %edx
jge 0x3319
movq (%rbx), %rcx
movslq %edx, %rdx
movslq %r13d, %rsi
movl (%rax,%rdx,4), %edi
movl %edi, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %rsi
jne 0x32e8
jmp 0x3319
cmpl %r13d, %edx
jge 0x3319
movq (%rbx), %rsi
movslq %edx, %rdi
movslq %r13d, %r8
movl %ebp, %eax
subl (%rcx,%rdi,4), %eax
cltd
idivl %ebp
movl %edx, (%rsi,%rdi,4)
incq %rdi
cmpq %rdi, %r8
jne 0x3306
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_O1/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 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
movq %rdi, %rbx
movslq %r13d, %r12
leaq 0x4(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x3(%rsp), %rcx
movq %r12, %rsi
callq 0x3fe0
testl %r12d, %r12d
jle 0x33ab
movq (%r15), %rcx
movq (%r14), %rsi
movq (%rbx), %rdi
movl %r13d, %r8d
andl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
xorl %r9d, %r9d
movl (%rsi,%r9,4), %eax
addl (%rcx,%r9,4), %eax
cltd
idivl %ebp
movl %edx, (%rdi,%r9,4)
incq %r9
cmpq %r9, %r8
jne 0x3394
movq (%r15), %rax
movq 0x8(%r15), %rsi
subq %rax, %rsi
movq (%r14), %rcx
movq 0x8(%r14), %rdi
subq %rcx, %rdi
movq %rdi, %rdx
shrq $0x2, %rdx
cmpq %rdi, %rsi
jbe 0x33e9
cmpl %r13d, %edx
jge 0x3405
movq (%rbx), %rcx
movslq %edx, %rdx
movslq %r13d, %rsi
movl (%rax,%rdx,4), %edi
movl %edi, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %rsi
jne 0x33d9
jmp 0x3405
cmpl %r13d, %edx
jge 0x3405
movq (%rbx), %rax
movslq %edx, %rdx
movslq %r13d, %rsi
movl (%rcx,%rdx,4), %edi
movl %edi, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rsi
jne 0x33f7
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_O1/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:
movq (%rdi), %rdx
movq 0x8(%rdi), %rcx
subq %rdx, %rcx
sete %al
je 0x343a
sarq $0x2, %rcx
cmpq $0x1, %rcx
movq %rcx, %rsi
adcq $0x0, %rsi
cmpl $0x0, (%rdx)
jle 0x343b
retq
movl $0x1, %edi
movq %rdi, %rax
cmpq %rdi, %rsi
je 0x3452
leaq 0x1(%rax), %rdi
cmpl $0x0, (%rdx,%rax,4)
jle 0x3440
cmpq %rax, %rcx
setbe %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x405e
movq %r14, %rdi
callq 0x3459
cltq
movq (%rbx), %rcx
movl $0x0, (%rcx,%rax,4)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3511
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2180
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/manschga[P]M5GB/other_fct.cpp
// Function: Create_binom_table(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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, (%rsp)
movq $0x0, 0x10(%rdi)
movl %esi, 0xc(%rsp)
testl %esi, %esi
js 0x36fa
movl %edx, %ebp
xorl %r13d, %r13d
leaq 0x10(%rsp), %r15
leaq 0x30(%rsp), %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
testl %ebp, %ebp
js 0x36c5
xorl %r14d, %r14d
movl %r13d, %ebx
cmpl %r14d, %ebx
movl %r14d, %ecx
cmovll %ebx, %ecx
movl %r13d, %eax
subl %r14d, %eax
jae 0x3652
xorl %eax, %eax
jmp 0x3689
cmpl %r14d, %eax
cmovgel %r14d, %eax
testl %eax, %eax
jle 0x3684
negl %ecx
movl $0x1, %edi
movl %r13d, %esi
movl $0x1, %eax
imull %esi, %eax
cltd
idivl %edi
leal (%rcx,%rdi), %edx
incl %edx
incl %edi
decl %esi
cmpl $0x1, %edx
jne 0x366c
cltq
jmp 0x3689
movl $0x1, %eax
movq %rax, 0x30(%rsp)
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x36a8
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x36b3
movq %r15, %rdi
movq %r12, %rdx
callq 0x43ce
leal 0x1(%r14), %eax
decl %ebx
cmpl %ebp, %r14d
movl %eax, %r14d
jne 0x363d
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x40de
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x36e8
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
leal 0x1(%r13), %eax
cmpl 0xc(%rsp), %r13d
movl %eax, %r13d
jne 0x361e
movq (%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x370f
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3729
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq (%rsp), %rdi
callq 0x303a
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/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 0x35dc
cmpl %esi, %ecx
cmovll %ecx, %esi
testl %esi, %esi
jle 0x35dd
negl %esi
movl $0x1, %ecx
movl $0x1, %eax
imull %edi, %eax
cltd
idivl %ecx
leal (%rsi,%rcx), %edx
incl %edx
incl %ecx
decl %edi
cmpl $0x1, %edx
jne 0x35c8
retq
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
je 0x3763
sarq $0x2, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %edi, %edi
xorl %ecx, %ecx
addl (%rax,%rdi,4), %ecx
incq %rdi
cmpq %rdi, %rdx
jne 0x3756
jmp 0x3765
xorl %ecx, %ecx
movl %ecx, %edx
addl %esi, %edx
jle 0x3788
movq 0x16a0e(%rip), %rdi     # 0x1a180
movl %edx, %edx
leaq (%rdx,%rdx,2), %rdx
movslq %esi, %r8
movq -0x18(%rdi,%rdx,8), %rdx
movl (%rdx,%r8,8), %edx
incl %edx
jmp 0x378d
movl $0x1, %edx
testl %esi, %esi
jle 0x37d2
movq 0x169e8(%rip), %rdi     # 0x1a180
addq $-0x18, %rdi
movl %esi, %esi
subl -0x4(%rax,%rsi,4), %ecx
testl %ecx, %ecx
jle 0x37c5
leaq (%rsi,%rcx), %r8
decq %r8
testl %r8d, %r8d
jle 0x37c5
movl %r8d, %r8d
leaq (%r8,%r8,2), %r8
movq (%rdi,%r8,8), %r8
movl %ecx, %r9d
addl -0x8(%r8,%r9,8), %edx
decq %rsi
leaq 0x1(%rsi), %r8
cmpq $0x1, %r8
jg 0x379e
movslq %edx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testl %esi, %esi
jle 0x383b
movl %edx, %ebp
movl %esi, %r14d
xorl %r15d, %r15d
leaq 0xc(%rsp), %r12
movl %r15d, %edi
movl %ebp, %esi
callq 0x386a
movl %eax, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x3828
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x3833
movq %rbx, %rdi
movq %r12, %rdx
callq 0x46f2
incl %r15d
cmpl %r15d, %r14d
jne 0x3804
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3862
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2180
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/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:
testl %edi, %edi
jle 0x38e7
pushq %rbp
pushq %rbx
leal -0x1(%rsi), %r8d
xorl %r9d, %r9d
movl %r8d, %r10d
xorl %ecx, %ecx
testl %esi, %esi
setle %al
cmpl %r8d, %r9d
movl %r8d, %r11d
cmovll %r9d, %r11d
movl %r9d, %edx
addl %esi, %edx
setle %dl
orb %al, %dl
movl $0x0, %eax
jne 0x38d6
cmpl %r9d, %r8d
movl %r9d, %eax
cmovll %r8d, %eax
testl %eax, %eax
jle 0x38d1
negl %r11d
movl $0x1, %ebx
movl %r10d, %ebp
movl $0x1, %eax
imull %ebp, %eax
cltd
idivl %ebx
decl %ebp
leal (%r11,%rbx), %edx
incl %edx
incl %ebx
cmpl $0x1, %edx
jne 0x38ba
jmp 0x38d6
movl $0x1, %eax
addl %eax, %ecx
incl %r9d
incl %r10d
cmpl %edi, %r9d
jne 0x387c
popq %rbx
popq %rbp
jmp 0x38e9
xorl %ecx, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
movq 0x8(%rsi), %rcx
subq (%rsi), %rcx
cmpq %rcx, %rax
je 0x39f5
movq 0x166c0(%rip), %r15     # 0x19fd8
leaq 0xf7e8(%rip), %rsi      # 0x13107
movl $0x20, %edx
movq %r15, %rdi
callq 0x21a0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
leaq 0xf7ce(%rip), %rsi      # 0x13128
movl $0x8, %edx
movq %r15, %rdi
callq 0x21a0
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x2, %rsi
movq %r15, %rdi
callq 0x20e0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
leaq 0xf786(%rip), %rsi      # 0x13131
movl $0x8, %edx
movq %r15, %rdi
callq 0x21a0
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x2, %rsi
movq %r15, %rdi
callq 0x20e0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq (%r14), %rcx
movq 0x8(%r14), %rax
subq %rcx, %rax
je 0x3a29
sarq $0x2, %rax
cmpq $0x1, %rax
adcq $0x0, %rax
movq (%rbx), %rdi
xorl %r8d, %r8d
xorl %esi, %esi
xorl %edx, %edx
addl (%rdi,%r8,4), %edx
addl (%rcx,%r8,4), %esi
incq %r8
cmpq %r8, %rax
jne 0x3a17
jmp 0x3a2d
xorl %edx, %edx
xorl %esi, %esi
movb $0x1, %al
cmpl %esi, %edx
jl 0x3a74
jle 0x3a39
xorl %eax, %eax
jmp 0x3a74
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
subq %rax, %rdx
shrq $0x2, %rdx
movl %edx, %esi
movl %esi, %edx
testl %esi, %esi
jle 0x3a6c
movl -0x4(%rax,%rsi,4), %edi
movl -0x4(%rcx,%rsi,4), %r8d
cmpl %r8d, %edi
jg 0x3a69
decq %rsi
cmpl %r8d, %edi
jge 0x3a49
xorl %edi, %edi
jmp 0x3a6c
movb $0x1, %dil
testl %edx, %edx
setle %al
orb %dil, %al
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
subq (%rdi), %rax
movq 0x8(%rsi), %rcx
subq (%rsi), %rcx
cmpq %rcx, %rax
je 0x3ae2
movq 0x16531(%rip), %r15     # 0x19fd8
leaq 0xf68c(%rip), %rsi      # 0x1313a
movl $0x1f, %edx
movq %r15, %rdi
callq 0x21a0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq (%r14), %rdx
movq 0x8(%r14), %rcx
subq %rdx, %rcx
sete %al
je 0x3b2d
sarq $0x2, %rcx
cmpq $0x1, %rcx
movq %rcx, %rsi
adcq $0x0, %rsi
movq (%rbx), %rdi
movl (%rdx), %r8d
cmpl (%rdi), %r8d
jne 0x3b2d
movl $0x1, %r8d
movq %r8, %rax
cmpq %r8, %rsi
je 0x3b27
movl (%rdx,%rax,4), %r9d
leaq 0x1(%rax), %r8
cmpl (%rdi,%rax,4), %r9d
je 0x3b11
cmpq %rax, %rcx
setbe %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq 0x8(%rsi), %rbp
subq (%rsi), %rbp
shrq $0x2, %rbp
movslq %ebp, %r13
xorl %r14d, %r14d
leaq 0x14(%rsp), %rdx
movl %r14d, (%rdx)
movq %r13, %rsi
callq 0x4812
leaq 0x10(%rsp), %rdx
movl %r14d, (%rdx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4812
testl %r13d, %r13d
jle 0x3bc7
movq (%r12), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq (%r15), %rdx
movq (%rbx), %rsi
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorl %edi, %edi
movl (%rax,%rdi,4), %r8d
subl (%rcx,%rdi,4), %r8d
movq %rdx, %r9
cmovgq %rsi, %r9
movl %r8d, %r10d
negl %r10d
cmovsl %r8d, %r10d
movl %r10d, (%r9,%rdi,4)
incq %rdi
cmpq %rdi, %rbp
jne 0x3ba2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x2, %rsi
subq %rax, %rcx
je 0x3f61
cmpq $0x1, %rsi
movq %rsi, %rdi
adcq $0x0, %rdi
xorl %r8d, %r8d
xorl %edx, %edx
addl (%rax,%r8,4), %edx
incq %r8
cmpq %r8, %rdi
jne 0x3f53
jmp 0x3f63
xorl %edx, %edx
testl %edx, %edx
je 0x3f86
xorl %edi, %edi
cmpq $0x2, %rsi
jb 0x3f92
movl $0x1, %r8d
cmpl $0x0, (%rax,%r8,4)
jg 0x3f8f
incq %r8
cmpq %r8, %rsi
jne 0x3f75
jmp 0x3f92
movl $0x1, -0x4(%rax,%rcx)
retq
movl %r8d, %edi
testl %edi, %edi
je 0x3fb0
movl (%rax), %ecx
movl $0x0, (%rax)
movl %edi, %edx
decl (%rax,%rdx,4)
movl -0x4(%rax,%rdx,4), %esi
addl %esi, %ecx
incl %ecx
movl %ecx, -0x4(%rax,%rdx,4)
retq
movl $0x0, (%rax)
incl %edx
movl %edx, -0x4(%rax,%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x20(%rsp), %rdi
movl %eax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq %rax, 0x18(%rdi)
movq %rsp, %rdx
movl %eax, (%rdx)
movups %xmm0, 0x8(%rdx)
movq %rax, 0x18(%rdx)
movq (%rsi), %rsi
movq (%r14), %rcx
callq 0x104eb
leaq 0x28(%rsp), %rdx
leaq 0xb0(%rsp), %rdi
movq %r15, %rsi
callq 0x5e36
movl 0x20(%rsp), %edx
leaq 0xe8(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
movl $0x1, %ecx
callq 0x5eb4
leaq 0x8(%rsp), %rdx
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x5e36
movl (%rsp), %edx
leaq 0x78(%rsp), %rdi
leaq 0x40(%rsp), %rsi
movl $0x1, %ecx
callq 0x5eb4
leaq 0xe8(%rsp), %rsi
leaq 0x78(%rsp), %rdx
movq %rbx, %rdi
callq 0x5f84
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x4d9c
movq 0x88(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x4db3
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq 0xe8(%rsp), %rdi
testq %rdi, %rdi
je 0x4dd0
movq 0xf8(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x4ded
movq 0xc0(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4e04
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x4e1b
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x4e4d
movq 0x88(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x4e4d
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x4e69
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x4e69
movq %rax, %rbx
movq 0xe8(%rsp), %rdi
testq %rdi, %rdi
je 0x4e8b
movq 0xf8(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x4e8b
movq %rax, %rbx
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x4eaf
movq 0xc0(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x4eaf
jmp 0x4eac
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4ec6
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x4edd
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/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
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rsi
cmpq %rsi, 0x8(%r14)
je 0x51bf
xorl %r15d, %r15d
movabsq $0x6db6db6db6db6db7, %r12 # imm = 0x6DB6DB6DB6DB6DB7
xorl %r13d, %r13d
addq %r15, %rsi
movq %rbx, %rdi
callq 0x605c
incq %r13
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
imulq %r12, %rax
addq $0x38, %r15
cmpq %r13, %rax
ja 0x5196
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3106
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/manschga[P]M5GB/./lab_poly.h
// Function: Lab_poly::Multiply(std::vector<int, std::allocator<int>> const&) const
Lab_poly Multiply(const vector<int>& t) const//multiply with monomial in vector vector
  {
      /*
      cout << "multiply lab poly with term" << endl;
      cout << "polynomial:" << (this->_poly)*t;
      cout << "signature: " << (this->_signature)*t;
      */
    return Lab_poly((this->_poly).Multiply(t),(this->_signature).Multiply(t));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x61f0
addq $0x20, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x62a2
movq %rdx, %rcx
movq %rsp, %rsi
movq %rbx, %rdi
movl %eax, %edx
callq 0x4bf0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5e85
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5eab
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rdi, %rbx
testl %ecx, %ecx
je 0x5f02
leaq 0x30(%rsp), %r12
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl $0x1, %ecx
callq 0x6402
movl 0x20(%r14), %edx
movq 0x28(%r14), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4bf0
movq 0x20(%rsp), %rdi
jmp 0x5f39
leaq 0x20(%r14), %r15
leaq 0x10(%rsp), %r12
movq %rsp, %rdi
movq %r14, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0x6402
movslq %ebp, %rsi
movq %r15, %rdi
callq 0x64ca
movq %rdx, %rcx
movq %rsp, %rsi
movq %rbx, %rdi
movl %eax, %edx
callq 0x4bf0
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5f4a
movq (%r12), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
jmp 0x5f6b
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5f7c
movq (%r12), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8(%rsp), %rdi
callq 0x6640
addq $0x20, %r15
addq $0x20, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x1213f
movl (%rax), %ebp
movq 0x8(%rax), %r14
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6314
movl 0x20(%rsp), %eax
leaq 0x28(%rsp), %rsi
movl %eax, 0x18(%rsi)
movq %rbx, %rdi
movl %ebp, %edx
movq %r14, %rcx
callq 0x4bf0
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x5ff9
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6010
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x603d
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x603d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6054
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %r15, %rdi
callq 0x6314
movq (%r15), %rdi
cmpq %rdi, 0x8(%r15)
je 0x624f
xorl %r15d, %r15d
xorl %r12d, %r12d
addq %r15, %rdi
movq %r14, %rsi
callq 0x638c
movq (%rsp), %rcx
movq %rax, (%rcx,%r15)
movq %rdx, 0x8(%rcx,%r15)
incq %r12
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
sarq $0x4, %rax
addq $0x10, %r15
cmpq %r12, %rax
ja 0x621b
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x103e8
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6270
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x6281
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x629a
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/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
je 0x62fa
sarq $0x2, %rax
leaq 0x13ea3(%rip), %rdx     # 0x1a168
movq (%rdx), %rdx
cmpq $0x1, %rax
adcq $0x0, %rax
xorl %r8d, %r8d
movl (%rcx,%r8,4), %r9d
testl %r9d, %r9d
jle 0x62f2
leaq (%rsi,%rsi,2), %rsi
shlq $0x4, %rsi
movq 0x18(%rdx,%rsi), %rsi
movq (%rsi,%r8,8), %rsi
decl %r9d
jne 0x62dc
incq %r8
cmpq %rax, %r8
jne 0x62d3
movl (%rdi), %edx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x12128
movl (%rbx), %eax
movq 0x8(%rbx), %rdx
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/manschga[P]M5GB/./poly.h
// Function: monomial::Multiply(std::vector<int, std::allocator<int>> const&) const
monomial Multiply(const term_vec& t) const//multiply with term t in vector formulation
{
  /*
  cout << "new multiplication!" << endl;
  cout << "t in multply: " << endl;
  for (int i = 0; i < t.size(); ++i)
    {
      cout << t[i] << ",";
    }
  cout << endl;
  */
  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
	    {
	      //cout << "result before multiplication: " << result <<  endl;
	      result = table[result].second[i]; //multiply with x_i+1
	      //cout << "result after multiplication: " << result << endl;
	  // cout << "before term" << new_term[i] << endl;
	  //cout << "t[i]" << t[i] << endl;
	      //	  new_term[i] += t_vec[i];
	  //cout << "after term" << new_term[i] << endl;
	    }
	}
  return monomial(result,this->_coeff,this->_p);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl (%rdi), %eax
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
subq %rcx, %rdx
je 0x63e1
sarq $0x2, %rdx
leaq 0x13dbe(%rip), %rsi     # 0x1a168
movq (%rsi), %rsi
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %r8d, %r8d
movl (%rcx,%r8,4), %r9d
testl %r9d, %r9d
jle 0x63d9
cltq
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movq 0x18(%rsi,%rax), %rax
movl (%rax,%r8,8), %eax
decl %r9d
jne 0x63c1
incq %r8
cmpq %rdx, %r8
jne 0x63b8
movslq %eax, %rsi
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %ecx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x102ec
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/manschga[P]M5GB/./poly.h
// Function: polynomial::Multiply(int, bool) const
polynomial Multiply(const int t, bool is_constant) const//multiply with constant / term
      {
	//if (is_constant)
	//{
	    vector<monomial> mons = this->_monomials;
	    for (int i = 0; i < mons.size(); ++i)
	      {
		mons[i] = mons[i].Multiply(t,is_constant); //is_constant
		//determines whether term or constant multiplication
	      }
	    return polynomial(mons);
	    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6314
movq (%r15), %rdi
cmpq %rdi, 0x8(%r15)
je 0x6471
movslq %r14d, %r14
xorl %r15d, %r15d
movzbl %bpl, %ebp
xorl %r12d, %r12d
addq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x6546
movq 0x8(%rsp), %rcx
movq %rax, (%rcx,%r15)
movq %rdx, 0x8(%rcx,%r15)
incq %r12
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
subq %rdi, %rax
sarq $0x4, %rax
addq $0x10, %r15
cmpq %r12, %rax
ja 0x6439
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x103e8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x6495
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x64a7
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x64c1
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/manschga[P]M5GB/./poly.h
// Function: monomial::Multiply(long, bool) const
monomial Multiply(const term_int t, bool is_constant) const//multiply with constant / term, can remove table for constant case
{
  if (is_constant)//multiply with constant
    {
      return monomial(this->_term,(this->_coeff*t) % (this->_p),this->_p);
    }
  else {
    term_vec t_vec = table[t].first; //get vector repr of t
    term_int result = this->_term; //monomial in integer format
    for (int i = 0; i < t_vec.size(); ++i)
      {
	for (int j = 0; j < t_vec[i]; ++j) //read up from mult table
	  {
	    
	    result = table[result].second[i]; //multiply with x_i+1
	  }
      }
    return monomial(result,this->_coeff,this->_p);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
testl %edx, %edx
je 0x657c
movq (%rbx), %r8
movslq 0x8(%rbx), %rax
imulq %rsi, %rax
movslq 0xc(%rbx), %rcx
cqto
idivq %rcx
leaq 0x8(%rsp), %rdi
movq %r8, %rsi
callq 0x102ec
jmp 0x6609
leaq 0x13be5(%rip), %r15     # 0x1a168
leaq (%rsi,%rsi,2), %rsi
shlq $0x4, %rsi
addq (%r15), %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x405e
movq (%rbx), %rsi
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
je 0x65e2
sarq $0x2, %rcx
movq (%r15), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edi, %edi
movl (%rax,%rdi,4), %r8d
testl %r8d, %r8d
jle 0x65da
leaq (%rsi,%rsi,2), %rsi
shlq $0x4, %rsi
movq 0x18(%rdx,%rsi), %rsi
movq (%rsi,%rdi,8), %rsi
decl %r8d
jne 0x65c4
incq %rdi
cmpq %rcx, %rdi
jne 0x65bb
movl 0x8(%rbx), %edx
movl 0xc(%rbx), %ecx
leaq 0x8(%rsp), %rdi
callq 0x102ec
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x6609
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x6637
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O1/manschga[P]M5GB/./poly.h
// Function: polynomial::operator-(polynomial const&) const
polynomial operator-(const polynomial& rhs) const
  {
    
    //construct -rhs and call f + -rhs
    vector<monomial> minus_mon_rhs = {};
    for (int i = 0; i < rhs.Get_monomials().size(); ++i)
      {
	minus_mon_rhs.emplace_back(monomial(rhs.Get_monomials()[i].Get_term(),(rhs.Get_p()-rhs.Get_monomials()[i].Get_coeff()) % rhs.Get_p(),rhs.Get_monomials()[i].Get_p()));
      }
    polynomial minus_rhs(minus_mon_rhs);
    
    //cout << "succesful until subtraction!" << endl;
    return (*this + minus_rhs);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq (%rdx), %rcx
cmpq %rcx, 0x8(%rdx)
je 0x66df
movq %rdx, %r15
movl $0xc, %ebp
xorl %r14d, %r14d
leaq 0x28(%rsp), %r12
movq %rsp, %r13
movq -0xc(%rcx,%rbp), %rsi
movl 0xc(%rcx), %edi
movl %edi, %eax
subl -0x4(%rcx,%rbp), %eax
cltd
idivl %edi
movl (%rcx,%rbp), %ecx
movq %r12, %rdi
callq 0x102ec
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x66ba
movups 0x28(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rsp)
jmp 0x66c5
movq %r13, %rdi
movq %r12, %rdx
callq 0x6ba8
incq %r14
movq (%r15), %rcx
movq 0x8(%r15), %rax
subq %rcx, %rax
sarq $0x4, %rax
addq $0x10, %rbp
cmpq %r14, %rax
ja 0x6682
leaq 0x28(%rsp), %rdi
movq %rsp, %rsi
callq 0x103e8
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
callq 0x677c
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x6715
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x672b
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x675e
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
jmp 0x675e
jmp 0x675b
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6774
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/manschga[P]M5GB/M5GB.cpp
// Function: Syzygy(signature const&, std::vector<std::vector<long, std::allocator<long>>, std::allocator<std::vector<long, std::allocator<long>>>> const&)
bool Syzygy(const signature& sign, const Syzygies& H)
{
  int i = sign.Get_index();
  //  int sign_term = S.Get_term();
  //checks if S is known syzygy, order H by term, then faster!
  for (auto it = H[i].begin(); it != H[i].end(); ++it)
    {
      if (*it == sign.Get_term()) //fast check, if H > S then H does not divide S
	{
	  return true;
	}
    }
  for (auto it = H[i].begin(); it != H[i].end(); ++it)
    {
      if (*it < sign.Get_term()) //fast check, if H > S then H does not divide S
	{
	  if (isDivisible(table[sign.Get_term()].first,table[*it].first)) //look it up or faster by memory?
	    {
	      //cout << "signature H_i: " << H[i] << endl;
	      //cout << "signature from Spol: " << S << endl;
	      return true;
	    }
	}
    }
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq (%rdi), %rax
movq (%rsi), %rcx
leaq (%rax,%rax,2), %r15
movq (%rcx,%r15,8), %r12
movq 0x8(%rcx,%r15,8), %rax
cmpq %rax, %r12
je 0x81b2
movq 0x8(%r14), %rcx
movq %r12, %rdx
cmpq %rcx, (%rdx)
je 0x820b
addq $0x8, %rdx
cmpq %rax, %rdx
jne 0x81a4
movq (%rbx), %rax
cmpq 0x8(%rax,%r15,8), %r12
setne %bpl
je 0x820e
leaq 0x11fa1(%rip), %r13     # 0x1a168
movq (%r12), %rax
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
jge 0x81f7
movq (%r13), %rdx
leaq (%rcx,%rcx,2), %rdi
shlq $0x4, %rdi
addq %rdx, %rdi
leaq (%rax,%rax,2), %rsi
shlq $0x4, %rsi
addq %rdx, %rsi
callq 0x3bd6
testb %al, %al
jne 0x820e
addq $0x8, %r12
movq (%rbx), %rax
cmpq 0x8(%rax,%r15,8), %r12
setne %bpl
jne 0x81c7
jmp 0x820e
movb $0x1, %bpl
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/manschga[P]M5GB/M5GB.cpp
// Function: Update_syz(Lab_poly const&)
void Update_syz(const Lab_poly& Spol)
{
  for (auto& it : LT_G) 
    {
      //cout << "update syz" << Spol.Get_sign().Multiply(it.first) << it.second.Multiply(Spol.Get_LT())<< endl;
      signature temp = max(Spol.Get_sign().Multiply(it.first),it.second.Multiply(Spol.Get_LT()));
      H[temp.Get_index()].emplace_back(temp.Get_term());
    }
  return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x111a7(%rip), %rbp     # 0x1a258
testq %rbp, %rbp
je 0x9152
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
leaq 0x8(%rsp), %r15
leaq 0x18(%rsp), %r12
movq 0x8(%rbp), %rsi
movq %r14, %rdi
callq 0x64ca
movl %eax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x10(%rbp), %r13
movq %rbx, %rdi
callq 0xc69a
movslq %eax, %rsi
movq %r13, %rdi
callq 0x64ca
movl %eax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x1213f
movslq (%rax), %rcx
movq 0x8(%rax), %rax
movq 0x11327(%rip), %rdx     # 0x1a440
leaq (%rcx,%rcx,2), %rcx
leaq (%rdx,%rcx,8), %rdi
movq %rax, 0x8(%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x913d
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x9145
movq %r15, %rdx
callq 0x43ce
movq (%rbp), %rbp
testq %rbp, %rbp
jne 0x90cb
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/manschga[P]M5GB/M5GB.cpp
// Function: Add_to_M(Lab_poly const&)
void Add_to_M(const Lab_poly& F)
{
  term_int LT = F.Get_LT();
  M_conv[LT] = make_pair(table[LT].first,F.Get_sign());
  M.erase(LT);
  M[LT] = F.Get_poly();
  Generations_M.erase(LT);
  Generations_M[LT] = G_.size();
  Flags_M.erase(LT);
  Flags_M[LT] = Create_Flag(F.Get_poly());
  LT_M.erase(LT);
  LT_M[LT] = F.Get_sign();
  return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
callq 0xc69a
cltq
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
leaq 0x1091e(%rip), %rcx     # 0x1a168
leaq (%rax,%rax,2), %rsi
shlq $0x4, %rsi
addq (%rcx), %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x405e
movups 0x20(%rbx), %xmm0
movups %xmm0, 0x18(%r15)
leaq 0x1099e(%rip), %rdi     # 0x1a210
movq %r14, %rsi
callq 0xd948
movq %rax, %r14
leaq 0x20(%rbx), %r13
leaq 0x28(%rsp), %r12
leaq 0x10(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0xd7e4
movups (%r12), %xmm0
movups %xmm0, 0x18(%r14)
movq (%r15), %rdi
testq %rdi, %rdi
je 0x98b5
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
leaq 0x10a34(%rip), %r15     # 0x1a2f0
leaq 0x8(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xdcfa
movq %r15, %rdi
movq %r14, %rsi
callq 0xde2e
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x60e8
movl 0x18(%rbx), %eax
movl %eax, 0x18(%r15)
leaq 0x10add(%rip), %r15     # 0x1a3d0
movq %r15, %rdi
movq %r14, %rsi
callq 0xe152
movl 0x109cc(%rip), %ebp     # 0x1a2d0
movq %r15, %rdi
movq %r14, %rsi
callq 0xe288
movl %ebp, (%rax)
leaq 0x10a48(%rip), %r15     # 0x1a360
movq %r15, %rdi
movq %r14, %rsi
callq 0xe50c
movq %rbx, %rdi
callq 0x9ca5
movl %eax, %ebx
movq %rdx, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0xe642
movl %ebx, (%rax)
movq %r12, 0x8(%rax)
leaq 0x10938(%rip), %rbx     # 0x1a280
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe50c
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe642
movups (%r13), %xmm0
movups %xmm0, (%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x998f
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/manschga[P]M5GB/M5GB.cpp
// Function: Add_to_G(Lab_poly const&)
void Add_to_G(const Lab_poly& F)
{
  term_int LT = F.Get_LT();
  G_conv[LT] = make_pair(table[LT].first,F.Get_sign());
  G_[LT] = F.Get_poly();
  Generations_G[LT] = G_.size();
  LT_G[LT] = F.Get_sign();
  return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0xc69a
cltq
movq %rsp, %r14
movq %rax, (%r14)
leaq 0x107ad(%rip), %rcx     # 0x1a168
leaq (%rax,%rax,2), %rsi
shlq $0x4, %rsi
addq (%rcx), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x405e
movups 0x20(%rbx), %xmm0
movups %xmm0, 0x18(%r15)
leaq 0x107f5(%rip), %rdi     # 0x1a1d8
movq %r14, %rsi
callq 0xd948
movq %rax, %r14
leaq 0x20(%rbx), %r12
leaq 0x20(%rsp), %r13
leaq 0x8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0xd7e4
movups (%r13), %xmm0
movups %xmm0, 0x18(%r14)
movq (%r15), %rdi
testq %rdi, %rdi
je 0x9a26
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
leaq 0x1088b(%rip), %rdi     # 0x1a2b8
movq %rsp, %r14
movq %r14, %rsi
callq 0xde2e
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x60e8
movl 0x18(%rbx), %eax
movl %eax, 0x18(%r15)
movl 0x1087d(%rip), %ebx     # 0x1a2d0
leaq 0x1093e(%rip), %rdi     # 0x1a398
movq %r14, %rsi
callq 0xe288
movl %ebx, (%rax)
leaq 0x107dd(%rip), %rdi     # 0x1a248
movq %r14, %rsi
callq 0xe642
movups (%r12), %xmm0
movups %xmm0, (%rax)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x9aa3
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/manschga[P]M5GB/M5GB.cpp
// Function: Poly(std::unordered_map<long, polynomial, std::hash<long>, std::equal_to<long>, std::allocator<std::pair<long const, polynomial>>> const&, int, int)
vector<polynomial> Poly(const Basis& G, int n, int p)
{
  vector<polynomial> G_poly = {};
  G_poly.reserve(G_.size());// = {};
  for (auto it : G_) 
    {
      G_poly.emplace_back(it.second);
    }
  return G_poly;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x10804(%rip), %rsi     # 0x1a2d0
callq 0xc966
movq 0x107f0(%rip), %r15     # 0x1a2c8
testq %r15, %r15
je 0x9b29
leaq 0x10(%rsp), %r14
movq 0x8(%r15), %rax
movq %rax, 0x8(%rsp)
leaq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x6314
movl 0x28(%r15), %eax
movl %eax, 0x28(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xca40
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x9b21
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq (%r15), %r15
testq %r15, %r15
jne 0x9ae2
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x9b38
movq %rax, %r14
jmp 0x9b57
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x9b57
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x3106
movq %r14, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/manschga[P]M5GB/M5GB.cpp
// Function: Interreduce(std::vector<polynomial, std::allocator<polynomial>>&)
void Interreduce(vector<polynomial>& system)
{
  int size = 0;
  int size_before = 1;
  while(size != size_before)
    {
      cout << "reduction step: " << system.size() << endl;
      size_before = system.size();
      int reductions = reduce(system); //get the (unique) reduced gröbner basis
      cout << "after reduce: " << system.size() << endl;
      size = system.size();//maybe the size drops
      number_of_reductions += reductions;
    }
  cout << "end of reduction!" << endl;
  //sort(system); //test if this speeds up
  reverse(system.begin(),system.end());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1045c(%rip), %r14     # 0x19fd8
leaq 0x9874(%rip), %r12      # 0x133f7
movl $0x10, %edx
movq %r14, %rdi
leaq 0x9854(%rip), %rsi      # 0x133e6
callq 0x21a0
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x5, %rsi
movq %r14, %rdi
callq 0x20e0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq 0x8(%rbx), %r15
subq (%rbx), %r15
shrq $0x5, %r15
movq %rbx, %rdi
callq 0x10cf1
movl %eax, %ebp
movl $0xe, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x21a0
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x5, %rsi
movq %r14, %rdi
callq 0x20e0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x5, %rax
addl %ebp, 0x10569(%rip)     # 0x1a1b0
cmpl %r15d, %eax
jne 0x9b83
leaq 0x97af(%rip), %rsi      # 0x13406
movl $0x11, %edx
movq %r14, %rdi
callq 0x21a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf8cc