LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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), %ecx
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
leaq 0x12d0c(%rip), %rsi     # 0x18170
movq (%rsi), %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq %rdx, %r9
je 0x549a
movl (%rax,%r9,4), %r10d
testl %r10d, %r10d
cmovlel %r8d, %r10d
subl $0x1, %r10d
jb 0x5495
movslq %ecx, %rcx
imulq $0x30, %rcx, %rcx
movq 0x18(%rsi,%rcx), %rcx
movl (%rcx,%r9,8), %ecx
jmp 0x547d
incq %r9
jmp 0x546d
movslq %ecx, %rsi
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %ecx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xd4d0
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rdi
callq 0x53f8
movslq %r14d, %r14
xorl %r15d, %r15d
movzbl %bpl, %ebp
xorl %r12d, %r12d
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
subq %rdi, %rax
sarq $0x4, %rax
cmpq %r12, %rax
jbe 0x554b
addq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x55e6
movq 0x8(%rsp), %rcx
movq %rax, (%rcx,%r15)
movq %rdx, 0x8(%rcx,%r15)
incq %r12
addq $0x10, %r15
jmp 0x5511
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xd5a4
leaq 0x8(%rsp), %rdi
callq 0x2f74
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5574
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2f74
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5619
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 0xd4d0
jmp 0x5691
leaq 0x12b50(%rip), %r15     # 0x18170
imulq $0x30, %rsi, %rsi
addq (%r15), %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x3a1a
movq (%rbx), %rsi
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
movq (%r15), %rdx
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %rcx, %r8
je 0x5677
movl (%rax,%r8,4), %r9d
testl %r9d, %r9d
cmovlel %edi, %r9d
subl $0x1, %r9d
jb 0x5672
imulq $0x30, %rsi, %rsi
movq 0x18(%rdx,%rsi), %rsi
movq (%rsi,%r8,8), %rsi
jmp 0x565d
incq %r8
jmp 0x564d
movl 0x8(%rbx), %edx
movl 0xc(%rbx), %ecx
leaq 0x8(%rsp), %rdi
callq 0xd4d0
leaq 0x18(%rsp), %rdi
callq 0x2dfe
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x2dfe
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r15
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r12
andq $0x0, 0x10(%r12)
movaps %xmm0, (%r12)
pushq $0xc
popq %rbp
xorl %r14d, %r14d
leaq 0x28(%rsp), %r13
movq (%r15), %rcx
movq 0x8(%r15), %rax
subq %rcx, %rax
sarq $0x4, %rax
cmpq %r14, %rax
jbe 0x5734
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 %r13, %rdi
callq 0xd4d0
movq %r12, %rdi
movq %r13, %rsi
callq 0x57c0
incq %r14
addq $0x10, %rbp
jmp 0x56f1
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xd5a4
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x57f8
leaq 0x28(%rsp), %rdi
callq 0x2f74
leaq 0x10(%rsp), %rdi
callq 0x2f74
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2f74
jmp 0x578f
jmp 0x578c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2f74
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rcx
movq (%rsi), %rax
imulq $0x18, %rcx, %r15
movq (%rax,%r15), %r12
movq 0x8(%rax,%r15), %rcx
movq 0x8(%rdi), %rdx
movq %r12, %rsi
cmpq %rcx, %rsi
je 0x6abb
leaq 0x8(%rsi), %rdi
cmpq %rdx, (%rsi)
movq %rdi, %rsi
jne 0x6a96
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x116ae(%rip), %r13     # 0x18170
cmpq 0x8(%rax,%r15), %r12
setne %bpl
je 0x6aaa
movq (%r12), %rcx
movq 0x8(%r14), %rdx
cmpq %rdx, %rcx
jge 0x6af8
movq (%r13), %rax
imulq $0x30, %rdx, %rdi
addq %rax, %rdi
imulq $0x30, %rcx, %rsi
addq %rax, %rsi
callq 0x36f2
testb %al, %al
jne 0x6aaa
movq (%rbx), %rax
addq $0x8, %r12
jmp 0x6ac2
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/M5GB.cpp
// Function: isRewritable(Lab_poly const&, int)
bool isRewritable(const Lab_poly& F, const int generation)
{
  signature T = F.Get_sign();
  for (auto it : LT_G)
    {
      if (it.second.Get_index() == T.Get_index())
	{
	  if (isDivisible(table[T.Get_term()].first,table[it.second.Get_term()].first))
	    {
#ifdef NUMBER
	      //rewrite order num: F < G if F created before G, still some error in here!
	      if (generation < Generations_G.find(it.first)->second)
		{
		  /*
		  cout << "Gen(F) = " << generation << endl;
		  cout << "Gen(G) = " << Generations_G.find(it.first)->second << endl;
		  */
		  return true;
		}
	      
#endif
#ifdef RATIO
	      //define vG = v*G_i if S(vG_i) = S(F);
	      vector<int> v = get_remainder(table[T.Get_term()].first,table[it.second.Get_term()].first);
	      //rewrite order, for ratio, only need: LT(g) < LT(f)
	      if (F.Get_LT() > G_.find(it.first)->second.Multiply(v).Get_LT())
		{
#ifdef DEBUG
		  cout << F << "is rewritable by " << it.second << endl;
		  cout << F << "is rewritable by " << it.second.Multiply(v) << endl;
#endif
		  return true;
		}
#endif
	    }
	}
    }
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl 0x20(%rdi), %r15d
leaq 0x11746(%rip), %r13     # 0x18260
leaq 0x1164f(%rip), %r12     # 0x18170
movq %rdi, 0x38(%rsp)
imulq $0x30, 0x28(%rdi), %rbp
leaq 0x90(%rsp), %r14
movq %rbp, 0x30(%rsp)
movq (%r13), %r13
testq %r13, %r13
je 0x6c28
movups 0x8(%r13), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x18(%r13), %rax
movq %rax, 0x20(%rsp)
cmpl %r15d, 0x18(%rsp)
jne 0x6b38
movq (%r12), %rax
leaq (%rax,%rbp), %rdi
imulq $0x30, 0x20(%rsp), %rsi
addq %rax, %rsi
callq 0x36f2
testb %al, %al
je 0x6b38
movq (%r12), %rsi
addq %rbp, %rsi
movq %r14, %rdi
callq 0x3a1a
imulq $0x30, 0x20(%rsp), %rsi
addq (%r12), %rsi
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
callq 0x3a1a
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xd81b
movq %rbx, %rdi
callq 0x2dfe
movq %r14, %rdi
callq 0x2dfe
movq 0x38(%rsp), %rdi
callq 0x97f2
movl %eax, 0xc(%rsp)
leaq 0x116ec(%rip), %rdi     # 0x182c0
leaq 0x10(%rsp), %rsi
leaq 0x40(%rsp), %rbx
callq 0xbbe4
leaq 0x70(%rsp), %rbp
addq $0x10, %rax
movq %rbp, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x52fe
movq 0x70(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x8(%rsp)
movq %rbp, %rdi
callq 0x2f74
movq %rbx, %rdi
callq 0x2dfe
movl 0x8(%rsp), %eax
cmpl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rbp
jle 0x6b38
testq %r13, %r13
setne %al
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x40(%rsp), %rdi
jmp 0x6c61
movq %rax, %r15
leaq 0x58(%rsp), %rdi
callq 0x2dfe
jmp 0x6c59
movq %rax, %r15
movq %r14, %rdi
jmp 0x6c64
movq %rbx, %rdi
movq %rax, %r15
callq 0x2dfe
movq %r15, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
leaq 0x20(%rdi), %r14
leaq 0x10dd5(%rip), %rbp     # 0x18260
leaq 0x8(%rsp), %r15
leaq 0x18(%rsp), %r12
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x74ff
movq 0x8(%rbp), %rsi
movq %r14, %rdi
callq 0x558a
movl %eax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x10(%rbp), %r13
movq %rbx, %rdi
callq 0x97f2
movslq %eax, %rsi
movq %r13, %rdi
callq 0x558a
movl %eax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xebd5
movslq (%rax), %rcx
movq 0x8(%rax), %rax
imulq $0x18, %rcx, %rdi
addq 0x10f58(%rip), %rdi     # 0x18448
movq %rax, 0x8(%rsp)
movq %r15, %rsi
callq 0x3d62
jmp 0x7495
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x97f2
cltq
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
leaq 0x10913(%rip), %rcx     # 0x18170
imulq $0x30, %rax, %rsi
addq (%rcx), %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x3a1a
movups 0x20(%rbx), %xmm0
movups %xmm0, 0x18(%r15)
leaq 0x10997(%rip), %rdi     # 0x18218
movq %r14, %rsi
callq 0xab58
leaq 0x20(%rbx), %r13
leaq 0x10(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x982a
movq %r14, %rdi
callq 0x2dfe
leaq 0x10a4c(%rip), %r15     # 0x182f8
leaq 0x8(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0xaf42
movq %r15, %rdi
movq %r14, %rsi
callq 0xb08e
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4f12
leaq 0x10aff(%rip), %r15     # 0x183d8
movq %r15, %rdi
movq %r14, %rsi
callq 0xb374
movl 0x109ee(%rip), %ebp     # 0x182d8
movq %r15, %rdi
movq %r14, %rsi
callq 0xb4c0
movl %ebp, (%rax)
leaq 0x10a6a(%rip), %r15     # 0x18368
movq %r15, %rdi
movq %r14, %rsi
callq 0xb7bc
movq %rbx, %rdi
callq 0x7ba8
movl %eax, %ebx
movq %rdx, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0xb908
movl %ebx, (%rax)
movq %r12, 0x8(%rax)
leaq 0x1095a(%rip), %rbx     # 0x18288
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb7bc
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb908
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
leaq 0x10(%rsp), %rdi
callq 0x2dfe
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0x97f2
cltq
movq %rsp, %r14
movq %rax, (%r14)
leaq 0x107e0(%rip), %rcx     # 0x18170
imulq $0x30, %rax, %rsi
addq (%rcx), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3a1a
movups 0x20(%rbx), %xmm0
movups %xmm0, 0x18(%r15)
leaq 0x1082c(%rip), %rdi     # 0x181e0
movq %r14, %rsi
callq 0xab58
leaq 0x20(%rbx), %r15
leaq 0x8(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x982a
movq %r14, %rdi
callq 0x2dfe
leaq 0x108e1(%rip), %rdi     # 0x182c0
movq %rsp, %r14
movq %r14, %rsi
callq 0xb08e
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4f12
movl 0x108dd(%rip), %ebx     # 0x182d8
leaq 0x1099e(%rip), %rdi     # 0x183a0
movq %r14, %rsi
callq 0xb4c0
movl %ebx, (%rax)
leaq 0x1083d(%rip), %rdi     # 0x18250
movq %r14, %rsi
callq 0xb908
movups (%r15), %xmm0
movups %xmm0, (%rax)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2dfe
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x10877(%rip), %rsi     # 0x182d8
callq 0x9a44
leaq 0x10863(%rip), %r12     # 0x182d0
leaq 0x8(%rsp), %r14
movq %rsp, %r15
movq (%r12), %r12
testq %r12, %r12
je 0x7aa0
leaq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0x9ad8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9aec
movq %r14, %rdi
callq 0x2f74
jmp 0x7a75
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x7ab1
movq %rax, %r15
jmp 0x7ac1
movq %rax, %r15
movq %r14, %rdi
callq 0x2f74
movq %rbx, %rdi
callq 0x2c88
movq %r15, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %eax, %eax
pushq $0x1
popq %r13
movq 0x104ec(%rip), %r14     # 0x17fd8
leaq 0x7900(%rip), %r15      # 0xf3f3
leaq 0x790a(%rip), %r12      # 0xf404
cmpl %r13d, %eax
je 0x7b73
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x5, %rsi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20d0
movq 0x8(%rbx), %r13
subq (%rbx), %r13
shrq $0x5, %r13
movq %rbx, %rdi
callq 0xdc1d
movl %eax, %ebp
movq %r14, %rdi
movq %r12, %rsi
callq 0x2180
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
sarq $0x5, %rsi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x20d0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x5, %rax
addl %ebp, 0x10647(%rip)     # 0x181b8
jmp 0x7afa
movq 0x1045e(%rip), %rdi     # 0x17fd8
leaq 0x7892(%rip), %rsi      # 0xf413
callq 0x2180
movq %rax, %rdi
callq 0x20d0
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xcbed
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/M5GB.cpp
// Function: Create_Flag(polynomial const&)
signature Create_Flag(const polynomial& f)
{
  signature flag(table.size(),m); //cheap workaround, infinite signature
  for (auto monom = ++f.Get_monomials().begin(); monom != f.Get_monomials().end(); ++monom) //leave out LT, need to stay at that datastructure, otherwise for-loop! (poss error source)
    {
      term_int t = monom->Get_term();
      if (Generations_T.find(t)->second < G_.size()) //only do something then
	flag = min(flag,Create_term_flag(t));
      else
	flag = min(flag,Flags_T.find(t)->second);
    }
  return flag;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x105b0(%rip), %rcx     # 0x18170
movq 0x8(%rcx), %rax
subq (%rcx), %rax
pushq $0x30
popq %rcx
cqto
idivq %rcx
movl 0x105db(%rip), %edx     # 0x181b0
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl %eax, %esi
callq 0xebbe
movq (%rbx), %r13
addq $0x10, %r13
leaq 0x1081e(%rip), %r15     # 0x18410
leaq 0x8(%rsp), %r12
leaq 0x10732(%rip), %rbp     # 0x18330
cmpq 0x8(%rbx), %r13
je 0x7c67
movq (%r13), %rax
movq %rax, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xbc20
movslq 0x10(%rax), %rax
cmpq %rax, 0x106b5(%rip)     # 0x182d8
jbe 0x7c42
movq 0x8(%rsp), %rdi
callq 0x7df9
movl %eax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %r14, %rdi
leaq 0x28(%rsp), %rsi
jmp 0x7c54
movq %rbp, %rdi
movq %r12, %rsi
callq 0xbc02
leaq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0xec13
movups (%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
addq $0x10, %r13
jmp 0x7bfe
movl 0x10(%rsp), %eax
movq 0x18(%rsp), %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/M5GB.cpp
// Function: Check_TGFT(long, signature const&)
bool Check_TGFT(const term_int t_, const signature& T)
{
  #ifdef PRECISE_DEBUG
  cout << "TGFT called!" << endl;
  #endif
  for (auto& it : G_conv) 
    {
      //*
      if (t_ == it.first)
	{
	  signature test = it.second.second;//if divisor divides term, then term = divisor*remainderv);//check: needed whole multiple?
	  if (Smaller_sign(test,T)) //check if S(vG) < T
	    {
	      return true;
	    }
	}
    }
  for (auto& it : G_conv)
    {
      if (t_ > it.first)
	{
	  if (isDivisible(table[t_].first,it.second.first))
	    {
	      signature test = it.second.second.Multiply(get_remainder(table[t_].first, it.second.first));//if divisor divides term, then term = divisor*remainderv);//check: needed whole multiple?
	      if (Smaller_sign(test,T)) //check if S(vG) < T
		{
		  return true;
		}
	    }
	}
    }
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10556(%rip), %r12     # 0x181f0
leaq 0x30(%rsp), %r15
movq (%r12), %r12
testq %r12, %r12
je 0x7cd1
cmpq %r14, 0x8(%r12)
jne 0x7c9f
movups 0x28(%r12), %xmm0
movaps %xmm0, 0x30(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0xebf9
testb %al, %al
je 0x7c9f
movb $0x1, %bpl
jmp 0x7db5
movq %rbx, 0x10(%rsp)
leaq 0x10513(%rip), %r12     # 0x181f0
movq %r14, 0x18(%rsp)
imulq $0x30, %r14, %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %r13
leaq 0x30(%rsp), %r14
movq (%r12), %r12
testq %r12, %r12
setne %bpl
je 0x7db5
movq 0x18(%rsp), %rax
cmpq %rax, 0x8(%r12)
jge 0x7cf5
leaq 0x10457(%rip), %rax     # 0x18170
movq (%rax), %rdi
addq 0x8(%rsp), %rdi
leaq 0x10(%r12), %r15
movq %r15, %rsi
callq 0x36f2
testb %al, %al
je 0x7cf5
leaq 0x10437(%rip), %rax     # 0x18170
movq (%rax), %rsi
addq 0x8(%rsp), %rsi
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x3a1a
movq %r13, %rdi
movq %r15, %rsi
callq 0x3a1a
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %r15
movq %r13, %rbx
movq %r13, %rdx
callq 0xd81b
leaq 0x28(%r12), %rdi
movq %r14, %rsi
callq 0x538a
movl %eax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq %r14, %rdi
callq 0x2dfe
movq %rbx, %r13
movq %rbx, %rdi
callq 0x2dfe
movq %r15, %rdi
callq 0x2dfe
leaq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xebf9
testb %al, %al
je 0x7cf5
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2dfe
jmp 0x7dd8
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x2dfe
jmp 0x7de7
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x2dfe
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/M5GB.cpp
// Function: Add_field_eq(std::vector<polynomial, std::allocator<polynomial>>&, int)
void Add_field_eq(vector<polynomial>& system,int n)
{
  //assume field_eq are not in system yet!
  for (int i = 0; i < n; ++i)
    {
      //add x_i^p - x_i
      vector<int> x_p(n,0);
      x_p[i] = p;
      monomial one(0,1,p); //one-polynomial
      monomial mon_xp = one.Multiply(x_p);//multiply with x^p
      monomial minus_one(0,p-1,p); //-1-polynomial
      vector<int> x_1(n,0);//or n+1?
      x_1[i] = 1;
      monomial mon_x1 = minus_one.Multiply(x_1);

      //cout << "field_eq_i: "<< polynomial({mon_xp,mon_x1}) << endl;
      system.emplace_back(polynomial({mon_xp,mon_x1}));
    }
  //reverse(system.begin(),system.end());
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, 0x10(%rsp)
movslq %esi, %rcx
xorl %r14d, %r14d
testl %ecx, %ecx
movl $0x0, %eax
movq %rcx, 0x8(%rsp)
cmovgl %ecx, %eax
movq %rax, 0x18(%rsp)
leaq 0x98(%rsp), %r15
leaq 0x58(%rsp), %rbp
leaq 0x88(%rsp), %rbx
cmpq %r14, 0x18(%rsp)
je 0x8c34
andl $0x0, 0x58(%rsp)
movq %r15, %rdi
movq 0x8(%rsp), %rsi
movq %rbp, %rdx
leaq 0x20(%rsp), %rcx
callq 0x39c4
movl 0xf671(%rip), %ecx      # 0x181ac
movq 0x98(%rsp), %rax
movl %ecx, (%rax,%r14,4)
movq %rbx, %rdi
xorl %esi, %esi
pushq $0x1
popq %rdx
callq 0xd4d0
movq %rbx, %rdi
movq %r15, %rbx
movq %r15, %rsi
callq 0x5448
movq %rax, %r15
movq %rdx, %r13
movl 0xf63e(%rip), %ecx      # 0x181ac
leal -0x1(%rcx), %edx
leaq 0x78(%rsp), %rdi
xorl %esi, %esi
callq 0xd4d0
andl $0x0, 0x58(%rsp)
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq 0x8(%rsp), %rsi
movq %rbp, %rdx
leaq 0x20(%rsp), %rcx
callq 0x39c4
movq 0x40(%rsp), %rax
movl $0x1, (%rax,%r14,4)
leaq 0x78(%rsp), %rdi
movq %r12, %rsi
callq 0x5448
movq %r15, 0x20(%rsp)
movq %r13, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
leaq 0xb0(%rsp), %r13
movq %r13, %rdi
leaq 0x20(%rsp), %rsi
pushq $0x2
popq %rdx
leaq 0x7(%rsp), %rcx
callq 0x5ca8
movq %rbp, %rdi
movq %r13, %rsi
callq 0xd5a4
movq %rbx, %r15
leaq 0x88(%rsp), %rbx
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x992a
movq %rbp, %rdi
callq 0x2f74
movq %r13, %rdi
callq 0x2f74
leaq 0x40(%rsp), %rdi
callq 0x2dfe
movq %r15, %rdi
callq 0x2dfe
incq %r14
jmp 0x8b10
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8c48
movq %rax, %rbx
jmp 0x8c6c
movq %rax, %rbx
jmp 0x8c5f
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x2f74
leaq 0xb0(%rsp), %rdi
callq 0x2f74
leaq 0x40(%rsp), %rdi
callq 0x2dfe
jmp 0x8c81
jmp 0x8c7e
jmp 0x8c7e
jmp 0x8c7e
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x2dfe
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/M5GB.cpp
// Function: Basic_poly(std::vector<polynomial, std::allocator<polynomial>> const&, int)
vector<Lab_poly> Basic_poly(const vector<polynomial>& system_, int n)
{
  vector<Lab_poly> F = {};
  F.reserve(m);//(m);
  for (int i = 0; i < m; i++)
    {
      #ifdef LTPOT
      Lab_poly F_i(system_[i],signature(system_[i].Get_LT(),i));
      #endif
      #ifdef DPOT
      Lab_poly F_i(system_[i],signature(0,i));
      #endif
      //Lab_poly F_i(system_[i],signature(0,i)); -> is worse by a test!
      F.emplace_back(F_i);
    }
  return F;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movslq 0xf4f4(%rip), %rsi      # 0x181b0
callq 0x9966
xorl %r12d, %r12d
leaq 0x10(%rsp), %r15
leaq 0x30(%rsp), %r13
xorl %ebp, %ebp
movslq 0xf4d9(%rip), %rax      # 0x181b0
cmpq %rax, %rbp
jge 0x8d34
movq (%r14), %rsi
addq %r12, %rsi
movq %r15, %rdi
callq 0x57a2
movq (%r14), %rax
movq (%rax,%r12), %rax
movl (%rax), %esi
movq %rsp, %rdi
movl %ebp, %edx
callq 0xebbe
movl (%rsp), %edx
movq 0x8(%rsp), %rcx
movq %r13, %rdi
movq %r15, %rsi
callq 0x4524
movq %r15, %rdi
callq 0x2f74
movq %rbx, %rdi
movq %r13, %rsi
callq 0x9a08
movq %r13, %rdi
callq 0x2f74
incq %rbp
addq $0x20, %r12
jmp 0x8cd0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8d48
movq %rax, %r14
jmp 0x8d64
movq %rax, %r14
leaq 0x30(%rsp), %rdi
jmp 0x8d5f
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x2f74
movq %rbx, %rdi
callq 0x9908
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/M5GB.cpp
// Function: Init_LT_G(std::vector<Lab_poly, std::allocator<Lab_poly>> const&)
void Init_LT_G(const vector<Lab_poly> & F)
{
  for (auto it = F.begin(); it != F.end(); ++it)
    {
      LT_G[it->Get_LT()] = it->Get_sign();
      G_conv[it->Get_LT()] = make_pair(table[it->Get_LT()].first,it->Get_sign());
      M_conv[it->Get_LT()] = make_pair(table[it->Get_LT()].first,it->Get_sign());
    }
  //return LT_G;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
leaq 0x28(%rsp), %r13
leaq 0x10(%rsp), %r12
leaq 0xf3d7(%rip), %r15      # 0x18170
leaq 0x8(%rsp), %rbp
cmpq 0x8(%rbx), %r14
je 0x8e7f
movq %r14, %rdi
callq 0x97f2
cltq
movq %rax, 0x10(%rsp)
leaq 0xf492(%rip), %rdi      # 0x18250
movq %r12, %rsi
callq 0xbd0e
movups 0x20(%r14), %xmm0
movups %xmm0, (%rax)
movq %r14, %rdi
callq 0x97f2
cltq
imulq $0x30, %rax, %rsi
addq (%r15), %rsi
movq %r12, %rdi
callq 0x3a1a
movups 0x20(%r14), %xmm0
movups %xmm0, (%r13)
movq %r14, %rdi
callq 0x97f2
cltq
movq %rax, 0x8(%rsp)
leaq 0xf3d9(%rip), %rdi      # 0x181e0
movq %rbp, %rsi
callq 0xd31c
movq %rax, %rdi
movq %r12, %rsi
callq 0x982a
movq %r12, %rdi
callq 0x2dfe
movq %r14, %rdi
callq 0x97f2
cltq
imulq $0x30, %rax, %rsi
addq (%r15), %rsi
movq %r12, %rdi
callq 0x3a1a
movups 0x20(%r14), %xmm0
movups %xmm0, (%r13)
movq %r14, %rdi
callq 0x97f2
cltq
movq %rax, 0x8(%rsp)
leaq 0xf3bd(%rip), %rdi      # 0x18218
movq %rbp, %rsi
callq 0xd31c
movq %rax, %rdi
movq %r12, %rsi
callq 0x982a
movq %r12, %rdi
callq 0x2dfe
addq $0x38, %r14
jmp 0x8d9e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8e90
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2dfe
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/M5GB.cpp
// Function: Init_G(std::vector<Lab_poly, std::allocator<Lab_poly>> const&)
Basis Init_G(const vector<Lab_poly>& F)
{
  Basis G_ = {};
  for (auto it = F.begin(); it != F.end(); ++it)
    {
      G_[it->Get_LT()] = it->Get_poly(); //check: what if same LT in G_?
    }
  return G_;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x20(%rdi)
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movups %xmm0, 0x28(%rdi)
movq (%rsi), %r15
movq %rsp, %r12
cmpq 0x8(%r14), %r15
je 0x8f0f
movq %r15, %rdi
callq 0x97f2
cltq
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xced4
movq %rax, %rdi
movq %r15, %rsi
callq 0x4f12
addq $0x38, %r15
jmp 0x8edf
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x9d76
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/M5GB.cpp
// Function: Create_basis(std::vector<Lab_poly, std::allocator<Lab_poly>> const&)
Basis Create_basis(const vector<Lab_poly>& F)
{
  Basis basis;
  for (auto it = F.begin(); it != F.end(); ++it)
    {
      basis[it->Get_LT()] = it->Get_poly();
    }
  return basis;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movups %xmm0, 0x28(%rdi)
movq (%rsi), %r15
movq %rsp, %r12
cmpq 0x8(%r14), %r15
je 0x9423
movq %r15, %rdi
callq 0x97f2
cltq
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xced4
movq %rax, %rdi
movq %r15, %rsi
callq 0x4f12
addq $0x38, %r15
jmp 0x93f3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x9d76
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/M5GB.cpp
// Function: F_2(std::vector<Lab_poly, std::allocator<Lab_poly>> const&, int, int)
Spairs F_2(const vector<Lab_poly>& F, int n, int p)
{
  Spairs P = {};

  vector<int> zero(n,0);
  Lab_poly Zero(polynomial({monomial(0,0,p)}),signature(0,0));
  //cout << "Zero: " << Zero << endl;
  for (int i = 1; i < F.size(); ++i)
    {
      P.insert(make_pair(F[i],Zero));
      //    P.emplace_back(
    }
  //reverse(P.begin(),P.end()); 
  return P;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movl %ecx, %ebp
movq %rsi, %r14
leaq 0x8(%rdi), %rax
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rdi, 0x10(%rsp)
andq $0x0, 0x28(%rdi)
movslq %edx, %rsi
leaq 0xa8(%rsp), %rdx
andl $0x0, (%rdx)
leaq 0x58(%rsp), %rdi
leaq 0x70(%rsp), %rcx
callq 0x39c4
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
movl %ebp, %ecx
callq 0xd4d0
leaq 0xa8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
pushq $0x1
popq %r15
leaq 0xf(%rsp), %rcx
movq %r15, %rdx
callq 0x5ca8
leaq 0x38(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0xd5a4
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xebbe
movl 0x18(%rsp), %edx
movq 0x20(%rsp), %rcx
leaq 0x70(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x4524
leaq 0x38(%rsp), %rdi
callq 0x2f74
leaq 0xa8(%rsp), %r12
movq %r12, %rdi
callq 0x2f74
pushq $0x38
popq %rbx
leaq 0x70(%rsp), %r13
movq %rbx, %rbp
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
cqto
idivq %rbx
cmpq %r15, %rax
jbe 0x9564
addq %rbp, %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0xa922
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0xd008
movq %r12, %rdi
callq 0x61da
incq %r15
addq $0x38, %rbp
jmp 0x9524
leaq 0x70(%rsp), %rdi
callq 0x2f74
leaq 0x58(%rsp), %rdi
callq 0x2dfe
movq 0x10(%rsp), %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x95ad
jmp 0x9596
movq %rax, %r14
jmp 0x95d6
movq %rax, %r14
jmp 0x95e0
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x2f74
leaq 0xa8(%rsp), %rdi
jmp 0x95d1
movq %rax, %r14
leaq 0xa8(%rsp), %rdi
callq 0x61da
jmp 0x95cc
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x2f74
leaq 0x58(%rsp), %rdi
callq 0x2dfe
movq 0x10(%rsp), %rdi
callq 0x9f98
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/M5GB.cpp
// Function: Check_TGFT(long, signature const&, int)
bool Check_TGFT(const term_int t_, const signature& T, const int generation)//check only from generation to end
{
  for (auto& it : G_conv) 
    {
      //*
      if (t_ == it.first)
	{
	  signature test = it.second.second;//if divisor divides term, then term = divisor*remainderv);//check: needed whole multiple?
	  if (Smaller_sign(test,T)) //check if S(vG) < T
	    {
	      return true;
	    }
	}
    }
  for (auto& it : G_conv)
    {
      if (t_ > it.first && Generations_G.find(t_)->second > generation)
	{
	  if (isDivisible(table[t_].first,it.second.first))
	    {
	      signature test = it.second.second.Multiply(get_remainder(table[t_].first, it.second.first));//if divisor divides term, then term = divisor*remainderv);//check: needed whole multiple?
	      if (Smaller_sign(test,T)) //check if S(vG) < T
		{
		  return true;
		}
	    }
	}
    }
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, 0x14(%rsp)
movq %rsi, %rbx
movq %rdi, %r15
movq %rdi, 0x8(%rsp)
leaq 0xebda(%rip), %r13      # 0x181f0
leaq 0x30(%rsp), %r12
movq (%r13), %r13
testq %r13, %r13
je 0x9657
cmpq %r15, 0x8(%r13)
jne 0x961b
movups 0x28(%r13), %xmm0
movaps %xmm0, 0x30(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0xebf9
testb %al, %al
je 0x961b
movb $0x1, %bpl
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, 0x18(%rsp)
leaq 0xeb8d(%rip), %r15      # 0x181f0
leaq 0x48(%rsp), %r12
leaq 0x30(%rsp), %rbx
movq (%r15), %r15
testq %r15, %r15
setne %bpl
je 0x9646
movq 0x8(%rsp), %rax
cmpq 0x8(%r15), %rax
jle 0x966d
leaq 0xed15(%rip), %rdi      # 0x183a0
leaq 0x8(%rsp), %rsi
callq 0xbc20
movl 0x14(%rsp), %ecx
cmpl %ecx, 0x10(%rax)
jle 0x966d
imulq $0x30, 0x8(%rsp), %rdi
leaq 0xeac5(%rip), %rax      # 0x18170
addq (%rax), %rdi
leaq 0x10(%r15), %r13
movq %r13, %rsi
callq 0x36f2
testb %al, %al
je 0x966d
movq %rbx, %r14
imulq $0x30, 0x8(%rsp), %rsi
leaq 0xeaa2(%rip), %rax      # 0x18170
addq (%rax), %rsi
movq %r12, %rbx
leaq 0x60(%rsp), %r12
movq %r12, %rdi
callq 0x3a1a
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3a1a
movq %r14, %r13
movq %r14, %rdi
movq %r12, %rsi
movq %r12, %r14
movq %rbx, %r12
movq %rbx, %rdx
callq 0xd81b
leaq 0x28(%r15), %rdi
movq %r13, %rsi
callq 0x538a
movq %r13, %rbx
movl %eax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq %r13, %rdi
callq 0x2dfe
movq %r12, %rdi
callq 0x2dfe
movq %r14, %rdi
callq 0x2dfe
leaq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xebf9
testb %al, %al
je 0x966d
jmp 0x9646
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2dfe
jmp 0x9761
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x2dfe
jmp 0x9770
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x2dfe
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/./poly.h
// Function: monomial::operator==(monomial const&) const
bool operator == (const monomial &rhs) const
 {
   bool one = (*this > rhs);
   bool two = (*this<rhs);
   bool result = (!(*this>rhs)) && (!(*this<rhs));
   return result;
 }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xc8be
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5e22
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8be
testb %al, %al
je 0xc8a9
xorl %eax, %eax
jmp 0xc8b6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5e22
xorb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/poly.cpp
// Function: operator<<(std::ostream&, monomial const&)
ostream& operator<<(ostream& s, const monomial& rhs)
{
  //if (rhs._coeff > 1)
  cout << rhs._coeff << "*";
  cout << rhs._term;
  /*
  for (int i = 0; i < rhs._term.size()-1; ++i)
    {
      if (rhs._term[i] > 1)
	cout << char(97+i) << rhs._term[i];
      if (rhs._term[i] == 1)
	cout << char(97+i);
    }
  if (rhs._term[rhs._term.size()-1] > 1)
    cout << char(97+rhs._term.size()-1) << rhs._term[rhs._term.size()-1];
    if (rhs._term[rhs._term.size()-1] == 1)
      cout << char(97+rhs._term.size()-1);
  */
  return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %esi
movq 0xaae9(%rip), %r15      # 0x17fd8
movq %r15, %rdi
callq 0x2250
leaq 0x1f34(%rip), %rsi      # 0xf432
movq %rax, %rdi
callq 0x2180
movq (%rbx), %rsi
movq %r15, %rdi
callq 0x2170
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/poly.cpp
// Function: operator<<(std::ostream&, polynomial const&)
ostream& operator<<(ostream& s, const polynomial& rhs)
{
  for (int i = 0; i < rhs.size()-1; ++i)
    {
      cout << rhs._monomials[i] << "+";
    }
  cout << rhs._monomials[rhs.size()-1] <<",";
  return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, (%rsp)
xorl %r13d, %r13d
movabsq $-0x100000000, %rbp     # imm = 0xFFFFFFFF00000000
movq 0xa9d0(%rip), %r15      # 0x17fd8
leaq 0x1a4a(%rip), %r12      # 0xf059
xorl %ebx, %ebx
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
shlq $0x1c, %rax
addq %rbp, %rax
sarq $0x20, %rax
cmpq %rax, %rbx
jge 0xd64a
addq %r13, %rsi
movq %r15, %rdi
callq 0xd4da
movq %r15, %rdi
movq %r12, %rsi
callq 0x2180
incq %rbx
addq $0x10, %r13
jmp 0xd611
shlq $0x4, %rax
addq %rax, %rsi
movq 0xa980(%rip), %r14      # 0x17fd8
movq %r14, %rdi
callq 0xd4da
leaq 0x19f4(%rip), %rsi      # 0xf05b
movq %r14, %rdi
callq 0x2180
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/poly.cpp
// Function: lcm(std::pair<int, std::vector<int, std::allocator<int>>>&, monomial const&, std::pair<int, std::vector<int, std::allocator<int>>>&, monomial const&)
void lcm(pair<int,vector<int>>& u, const monomial& LM_f, pair<int,vector<int>>& v, const monomial& LM_g)
{
  vector<int> term_f = table[LM_f.Get_term()].first;
  vector<int> term_g = table[LM_g.Get_term()].first;
  vector<int> term_u,term_v; //terms for u,v
  lcm(term_u,term_f,term_v,term_g);//get lcm on term level
  int c_u = Inverse(LM_f.Get_coeff(),LM_f.Get_p());//construct coeff of u,v
  int c_v = Inverse(LM_g.Get_coeff(),LM_g.Get_p());
  u = make_pair(c_u,term_u); //monomials in vector form
  v = make_pair(c_v,term_v);
  return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
leaq 0xaaca(%rip), %r13      # 0x18170
imulq $0x30, (%rsi), %rsi
addq (%r13), %rsi
leaq 0x70(%rsp), %rdi
callq 0x3a1a
imulq $0x30, (%r15), %rsi
addq (%r13), %rsi
leaq 0x58(%rsp), %rdi
callq 0x3a1a
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x3a1a
leaq 0x20(%rsp), %rdi
leaq 0x70(%rsp), %rsi
movq %rsp, %rdx
leaq 0x40(%rsp), %rcx
callq 0x365d
leaq 0x40(%rsp), %rdi
callq 0x2dfe
movl 0x8(%r12), %edi
movl 0xc(%r12), %esi
callq 0x3274
movl %eax, %r12d
movl 0x8(%r15), %edi
movl 0xc(%r15), %esi
callq 0x3274
movl %eax, %ebp
leaq 0x90(%rsp), %r15
movl %r12d, -0x8(%r15)
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x3a1a
leaq 0x88(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0xe690
movq %r15, %rdi
callq 0x2dfe
movl %ebp, (%r12)
leaq 0x90(%rsp), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x3a1a
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0xe690
movq %r14, %rdi
callq 0x2dfe
movq %rsp, %rdi
callq 0x2dfe
leaq 0x20(%rsp), %rdi
callq 0x2dfe
leaq 0x58(%rsp), %rdi
callq 0x2dfe
leaq 0x70(%rsp), %rdi
callq 0x2dfe
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd7e5
jmp 0xd7e5
jmp 0xd7e5
jmp 0xd7e5
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2dfe
jmp 0xd7e8
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2dfe
leaq 0x20(%rsp), %rdi
callq 0x2dfe
leaq 0x58(%rsp), %rdi
callq 0x2dfe
leaq 0x70(%rsp), %rdi
callq 0x2dfe
movq %rbx, %rdi
callq 0x2260
movq %rax, %rbx
jmp 0xd804
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/poly.cpp
// Function: get_remainder(std::vector<int, std::allocator<int>>, std::vector<int, std::allocator<int>>)
term_vec get_remainder(term_vec term, term_vec divisor)//if divisor divides term, then term = divisor*remainder, is only on term level!
{
  //cout << "in remainder " << endl;
  //  int rem_coeff = mon.Get_coeff()*Inverse(divisor.Get_coeff(),divisor.Get_p());
  /*
  cout << "term_size: " << term.size() << endl;
  cout << "divisor size: " << divisor.size() << endl;
  cout << "in remainder " << endl;
  */
  term_vec rem_vec = {};
  if (term.size() != divisor.size())
    {
      cout << "Error in Remainder computation!" << endl;
    }
  for (int i = 0; i < term.size(); ++i)
    {
      //cout << "before emplace " << endl;
      rem_vec.emplace_back(term[i]-divisor[i]);
      //cout << "after emplace " << endl;
    }
  return rem_vec;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
movq 0x8(%rdx), %rcx
subq (%rdx), %rcx
cmpq %rcx, %rax
je 0xd86a
movq 0xa782(%rip), %rdi      # 0x17fd8
leaq 0x1bd7(%rip), %rsi      # 0xf434
callq 0x2180
movq %rax, %rdi
callq 0x20d0
xorl %r13d, %r13d
leaq 0xc(%rsp), %r12
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0xd8a4
movl (%rax,%r13,4), %eax
movq (%r14), %rcx
subl (%rcx,%r13,4), %eax
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x40aa
incq %r13
jmp 0xd872
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xd8b7
movq %rax, %r14
movq %rbx, %rdi
callq 0x2dfe
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/poly.cpp
// Function: Create_poly_system(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int)
vector<polynomial> Create_poly_system(const string& input_file, int n, int p)
{
  vector<polynomial> system = {};
  vector<int> input_vec;
  string line;
  ifstream myfile (input_file);
  if (myfile.is_open())
  {
    while (getline (myfile,line))
    {
      input_vec = {};
      int i = 0;
      while (i < line.size())
	{
	  input_vec.emplace_back(line[i]-48); //from char to int
	  i = i+2;
	}
      input_vec.pop_back();
      system.emplace_back(poly_from_vec(input_vec,n,p));
      //cout << "test function:" << poly_from_vec(input_vec,n,p);
    }
    myfile.close();
  }
  else cout << "Unable to open file";
  return system;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
movl %ecx, %ebp
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rsp)
movups %xmm0, (%rdi)
movaps %xmm0, (%rsp)
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x60(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x2220
leaq 0xd8(%rsp), %rdi
callq 0x2060
testb %al, %al
je 0xd9b0
leaq 0x20(%rsp), %r15
movq %rsp, %r12
leaq 0x40(%rsp), %r13
leaq 0x60(%rsp), %rdi
movq %r15, %rsi
callq 0x2040
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xd9c5
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xe80a
xorl %r14d, %r14d
cmpq %r14, 0x28(%rsp)
jbe 0xd988
movq 0x20(%rsp), %rax
movsbl (%rax,%r14), %eax
addl $-0x30, %eax
movl %eax, 0x40(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x40aa
addq $0x2, %r14
jmp 0xd95f
addq $-0x4, 0x8(%rsp)
movq %r13, %rdi
movq %r12, %rsi
movl %ebp, %ecx
callq 0xda49
movq %rbx, %rdi
movq %r13, %rsi
callq 0x992a
movq %r13, %rdi
callq 0x2f74
jmp 0xd935
movq 0xa621(%rip), %rdi      # 0x17fd8
leaq 0x1a96(%rip), %rsi      # 0xf454
callq 0x2180
jmp 0xd9cf
leaq 0x60(%rsp), %rdi
callq 0x2050
leaq 0x60(%rsp), %rdi
callq 0x2070
leaq 0x20(%rsp), %rdi
callq 0x20c0
movq %rsp, %rdi
callq 0x2dfe
movq %rbx, %rax
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xda1a
movq %rax, %r14
jmp 0xda27
jmp 0xda1a
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x2f74
jmp 0xda1d
jmp 0xda1a
movq %rax, %r14
leaq 0x60(%rsp), %rdi
callq 0x2070
leaq 0x20(%rsp), %rdi
callq 0x20c0
movq %rsp, %rdi
callq 0x2dfe
movq %rbx, %rdi
callq 0x2c88
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/manschga[P]M5GB/poly.cpp
// Function: poly_from_vec(std::vector<int, std::allocator<int>> const&, int, int)
polynomial poly_from_vec(const vector<int>& vec, int n, int p)
{
  //  monomial constant(0,vec[vec.size()-1],p);
  vector<monomial> monomials = {};
  for (int i = 0; i < vec.size(); ++i)
    {
      if ((vec[i])%p > 0)
	{
	  monomials.emplace_back(monomial(vec.size()-i-1,(vec[i]),p));//new term with coefficient
	}
    }
  return polynomial(monomials);//.update();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r15
andq $0x0, 0x10(%r15)
movaps %xmm0, (%r15)
pushq $-0x1
popq %r13
xorl %ebx, %ebx
leaq 0x10(%rsp), %r12
movq (%r14), %rax
movq 0x8(%r14), %rsi
subq %rax, %rsi
sarq $0x2, %rsi
cmpq %rbx, %rsi
jbe 0xdabf
movl (%rax,%rbx,4), %ecx
movl %ecx, %eax
cltd
idivl %ebp
testl %edx, %edx
jle 0xdab7
addq %r13, %rsi
movq %rsi, 0x10(%rsp)
movl %ecx, 0x18(%rsp)
movl %ebp, 0x1c(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x57c0
incq %rbx
decq %r13
jmp 0xda7d
leaq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xd5a4
leaq 0x20(%rsp), %rdi
callq 0x2f74
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xdaef
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2f74
movq %rbx, %rdi
callq 0x2260